1 /* 2 ############################################################################## 3 # Copyright (c) 2000-2006 All rights reserved 4 # Alberto Reggiori <areggiori@webweaving.org> 5 # Dirk-Willem van Gulik <dirkx@webweaving.org> 6 # 7 # Redistribution and use in source and binary forms, with or without 8 # modification, are permitted provided that the following conditions 9 # are met: 10 # 11 # 1. Redistributions of source code must retain the above copyright 12 # notice, this list of conditions and the following disclaimer. 13 # 14 # 2. Redistributions in binary form must reproduce the above copyright 15 # notice, this list of conditions and the following disclaimer in 16 # the documentation and/or other materials provided with the 17 # distribution. 18 # 19 # 3. The end-user documentation included with the redistribution, 20 # if any, must include the following acknowledgment: 21 # "This product includes software developed by 22 # Alberto Reggiori <areggiori@webweaving.org> and 23 # Dirk-Willem van Gulik <dirkx@webweaving.org>." 24 # Alternately, this acknowledgment may appear in the software itself, 25 # if and wherever such third-party acknowledgments normally appear. 26 # 27 # 4. All advertising materials mentioning features or use of this software 28 # must display the following acknowledgement: 29 # This product includes software developed by the University of 30 # California, Berkeley and its contributors. 31 # 32 # 5. Neither the name of the University nor the names of its contributors 33 # may be used to endorse or promote products derived from this software 34 # without specific prior written permission. 35 # 36 # 6. Products derived from this software may not be called "RDFStore" 37 # nor may "RDFStore" appear in their names without prior written 38 # permission. 39 # 40 # THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 41 # ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 42 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 43 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 44 # FOR ANY DIRECT, INDIRECT, INCIDENTAL, 45 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 46 # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 47 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 49 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 50 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 51 # OF THE POSSIBILITY OF SUCH DAMAGE. 52 # 53 # ==================================================================== 54 # 55 # This software consists of work developed by Alberto Reggiori and 56 # Dirk-Willem van Gulik. The RDF specific part is based based on public 57 # domain software written at the Stanford University Database Group by 58 # Sergey Melnik. For more information on the RDF API Draft work, 59 # please see <http://www-db.stanford.edu/~melnik/rdf/api.html> 60 # The DBMS TCP/IP server part is based on software originally written 61 # by Dirk-Willem van Gulik for Web Weaving Internet Engineering m/v Enschede, 62 # The Netherlands. 63 # 64 ############################################################################## 65 # 66 # $Id: rdfstore.h,v 1.48 2006/06/19 10:10:23 areggiori Exp $ 67 # 68 */ 69 70 #ifndef _H_RDFSTORE 71 #define _H_RDFSTORE 72 73 #include <sys/param.h> 74 #include <netinet/in.h> 75 #include <dbms.h> 76 77 #ifdef SUNOS4 78 double strtod(); /* SunOS needed this */ 79 #endif 80 81 #include "rdfstore_flat_store.h" 82 #include "rdfstore_compress.h" 83 84 #define RDFSTORE_MAX_URI_LENGTH MAXPATHLEN /* not sure here - a URI can be longer probably */ 85 #define RDFSTORE_WORD_SPLITS "\v\f\n\r\t ,:;'\"!#$%^&*()~`_=+{}[]<>?.-/\\|" /* for free-text stuff */ 86 #define RDFSTORE_RDF_PARSETYPE_LITERAL "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral" 87 #define RDFSTORE_MAX_LANG_LENGTH 50 /* not sure here - a URI can be longer probably */ 88 89 #ifndef RDFSTORE_WORD_STEMMING 90 #define RDFSTORE_WORD_STEMMING (5) /* up to 5 chars from start or end of word */ 91 #endif 92 93 #if (! defined(RDFSTORE_MAXRECORDS)) || (RDFSTORE_MAXRECORDS < 128) 94 #define RDFSTORE_MAXRECORDS (2097152) 95 #endif 96 97 #define RDFSTORE_RECORDS_PER_BYTE 8 98 #define RDFSTORE_MAXRECORDS_BYTES_SIZE ( RDFSTORE_MAXRECORDS / RDFSTORE_RECORDS_PER_BYTE ) /* one bit per statement */ 99 100 #define RDFSTORE_MAX_FETCH_OBJECT_DEEPNESS 20 /* max levels to visit when return "coincise bounded description of a resource" */ 101 102 #define RDFSTORE_INDEXING_VERSION "20041222" /* which is even more modern than the SWAD-e paper one */ 103 104 /* very basic data types */ 105 106 typedef uint32_t rdf_store_digest_t; /* Hash Code */ 107 typedef dbms_counter rdf_store_counter_t; /* Counter type */ 108 109 #define RDFSTORE_NODE_TYPE_RESOURCE 0 110 #define RDFSTORE_NODE_TYPE_LITERAL 1 111 #define RDFSTORE_NODE_TYPE_BNODE 2 112 113 #define RDFSTORE_PARSE_TYPE_NORMAL 0 114 #define RDFSTORE_PARSE_TYPE_LITERAL 1 115 116 typedef struct RDF_Node { 117 int type; /* 0=resource, 1=literal and 2=bNode */ 118 union { 119 struct { 120 unsigned char * identifier; /* uri or nodeID */ 121 int identifier_len; 122 } resource; 123 struct { 124 unsigned char * string; 125 int string_len; 126 int parseType; /* 0=Resource 1=Literal i.e. XML */ 127 unsigned char lang[RDFSTORE_MAX_LANG_LENGTH]; 128 unsigned char * dataType; /* XMLSchema URI ref to the data type for the literal */ 129 } literal; 130 } value; 131 rdf_store_digest_t hashcode; /* see digest.c for details */ 132 struct rdfstore * model; /* for resource centric API ala Jena */ 133 } RDF_Node; 134 135 typedef struct RDF_Statement { 136 RDF_Node * subject; 137 RDF_Node * predicate; 138 RDF_Node * object; 139 RDF_Node * context; 140 RDF_Node * node; /* this represent a statement which is actually an RDF resource i.e. reification stuff */ 141 rdf_store_digest_t hashcode; /* see digest.c for details */ 142 int isreified; /* 0=stated 1=quoted ( should this be related to the above value union resource thingie??? ) */ 143 struct rdfstore * model; /* for resource centric API ala Jena */ 144 } RDF_Statement; 145 146 /* triple search pattern - quite generic with s,p,o and context (c) with free-text AND/OR/NOT words */ 147 #define RDFSTORE_TRIPLE_PATTERN_PART_RESOURCE_NODE 2000 148 #define RDFSTORE_TRIPLE_PATTERN_PART_LITERAL_NODE 2001 149 #define RDFSTORE_TRIPLE_PATTERN_PART_STRING 2002 150 typedef struct RDF_Triple_Pattern_Part { 151 int type; /* RDFSTORE_TRIPLE_PATTERN_PART_RESOURCE_NODE, RDFSTORE_TRIPLE_PATTERN_PART_LITERAL_NODE or RDFSTORE_TRIPLE_PATTERN_PART_STRING */ 152 union { 153 RDF_Node * node; 154 unsigned char * string; 155 } part; 156 struct RDF_Triple_Pattern_Part * next; 157 } RDF_Triple_Pattern_Part; 158 159 typedef struct RDF_Triple_Pattern { 160 struct RDF_Triple_Pattern_Part * subjects; /* OR space seprated URIs */ 161 unsigned int subjects_operator; /* 0=OR 1=AND 2=NOT */ 162 struct RDF_Triple_Pattern_Part * predicates; 163 unsigned int predicates_operator; 164 struct RDF_Triple_Pattern_Part * objects; 165 unsigned int objects_operator; 166 struct RDF_Triple_Pattern_Part * contexts; 167 unsigned int contexts_operator; 168 struct RDF_Triple_Pattern_Part * langs; 169 unsigned int langs_operator; 170 struct RDF_Triple_Pattern_Part * dts; 171 unsigned int dts_operator; 172 struct RDF_Triple_Pattern_Part * words; 173 unsigned int words_operator; 174 struct RDF_Triple_Pattern_Part * ranges; 175 unsigned int ranges_operator; /* One axe ranges (considering first element from ranges linked list): 176 177 1 = x < 22.34 178 2 = x <= .45 179 3 = x == 23.45 180 4 = x != 23.45 181 5 = x >= .748748 182 6 = x > .0002 183 184 Two axes ranges (considering first 2 elements from ranges linked list): 185 186 7 = 21.23 < x < 22.34 i.e. x > 21.23 && x < 22.34 187 8 = 21.23 <= x < 22.34 i.e. x >= 21.23 && x < 22.34 188 9 = 21.23 <= x <= 22.34 i.e. x >= 21.33 && x <= 22.34 189 10 = 21.23 < x <= 22.34 i.e. x > 21.33 && x <= 22.34 190 191 Values in ranges are euristacally parsed either to a long or double; and xsd_integer or xsd_double 192 special tables (b-trees) are used to answer the range question. If the RDF literal has an rdf:datatype 193 of xsd:date or xsd:dateTime, such range operations can be carried out on dataes using the xsd_date table. 194 195 */ 196 } RDF_Triple_Pattern; 197 198 #include "rdfstore_digest.h" 199 #include "rdfstore_iterator.h" 200 201 typedef struct rdfstore { 202 int flag; 203 int freetext; 204 int sync; 205 FLATDB * model; 206 FLATDB * statements; 207 FLATDB * nodes; 208 FLATDB * subjects; 209 FLATDB * predicates; 210 FLATDB * objects; 211 FLATDB * contexts; 212 FLATDB * languages; /* not used: but would index xml:lang into literals */ 213 FLATDB * datatypes; /* not used: but would index rdf:dataType into literals */ 214 FLATDB * s_connections; 215 FLATDB * p_connections; 216 FLATDB * o_connections; 217 FLATDB * windex; 218 FLATDB * xsd_integer; /* xsd:integer */ 219 FLATDB * xsd_double; /* xsd:float or xsd:double special one */ 220 FLATDB * xsd_date; /* xsd:date or xsd:dateTime */ 221 int remote; 222 int port; 223 RDF_Node * context; /* default context/statement-group stuff */ 224 struct rdfstore_iterator * cursor; 225 int attached; /* the number of items (cursors) currenlty attached */ 226 int tobeclosed; /* set to 1 means that the iterator attached has to close the storage itself */ 227 char version[10]; 228 229 char host[ MAXPATHLEN ]; 230 char uri[ RDFSTORE_MAX_URI_LENGTH ]; /* source URI */ 231 char name[ MAXPATHLEN ]; 232 233 unsigned char bits_encode[RDFSTORE_MAXRECORDS_BYTES_SIZE]; /* buffers for compression and decompression */ 234 unsigned char bits_decode[RDFSTORE_MAXRECORDS_BYTES_SIZE]; 235 236 /* Functions for encoding/decoding - MUST match */ 237 void(*func_encode)(unsigned int,unsigned char*, unsigned int *, unsigned char *); 238 void(*func_decode)(unsigned int,unsigned char*, unsigned int *, unsigned char *); 239 /* special ones for o_connections table - generally different compression algorithm from the above default one */ 240 void(*func_encode_connections)(unsigned int,unsigned char*, unsigned int *, unsigned char *); 241 void(*func_decode_connections)(unsigned int,unsigned char*, unsigned int *, unsigned char *); 242 FLATDB * prefixes; /* prefix mapping stuff - generally in-memory and default loaded on creation, otherwise could be persistent too */ 243 } rdfstore; 244 245 246 /* RDFStore core types API */ 247 248 RDF_Node * rdfstore_node_new(); 249 RDF_Node * rdfstore_node_clone( RDF_Node * node ); 250 int rdfstore_node_set_type( RDF_Node * node, int type ); 251 int rdfstore_node_get_type( RDF_Node * node ); 252 unsigned char * rdfstore_node_get_label( RDF_Node * node, int * len ); 253 unsigned char * rdfstore_node_to_string( RDF_Node * node, int * len ); 254 unsigned char * rdfstore_node_get_digest( RDF_Node * node, int * len ); 255 int rdfstore_node_equals( RDF_Node * node1, RDF_Node * node2 ); 256 int rdfstore_node_free( RDF_Node * node ); 257 void rdfstore_node_dump( RDF_Node * node ); 258 int rdfstore_node_set_model( RDF_Node * node, rdfstore * model ); /* for resource centric API ala Jena */ 259 int rdfstore_node_reset_model( RDF_Node * node ); 260 rdfstore * rdfstore_node_get_model( RDF_Node * node ); 261 262 /* RDF literals */ 263 264 RDF_Node * rdfstore_literal_new( unsigned char * string, int len, int parseType, unsigned char * lang, unsigned char * dt ); 265 RDF_Node * rdfstore_literal_clone( RDF_Node * node ); 266 unsigned char * rdfstore_literal_get_label( RDF_Node * node, int * len ); 267 unsigned char * rdfstore_literal_to_string( RDF_Node * node, int * len ); 268 unsigned char * rdfstore_literal_get_digest( RDF_Node * node, int * len ); 269 int rdfstore_literal_equals( RDF_Node * node1, RDF_Node * node2 ); 270 int rdfstore_literal_set_string( RDF_Node * node, unsigned char * string, int len ); 271 int rdfstore_literal_set_lang( RDF_Node * node, unsigned char * lang ); 272 unsigned char * rdfstore_literal_get_lang( RDF_Node * node ); 273 int rdfstore_literal_set_datatype( RDF_Node * node, unsigned char * dt ); 274 unsigned char * rdfstore_literal_get_datatype( RDF_Node * node ); 275 int rdfstore_literal_set_parsetype( RDF_Node * node, int parseType ); 276 int rdfstore_literal_get_parsetype( RDF_Node * node ); 277 int rdfstore_literal_free( RDF_Node * node ); 278 void rdfstore_literal_dump( RDF_Node * node ); 279 int rdfstore_literal_set_model( RDF_Node * node, rdfstore * model ); /* for resource centric API ala Jena */ 280 int rdfstore_literal_reset_model( RDF_Node * node ); 281 rdfstore * rdfstore_literal_get_model( RDF_Node * node ); 282 283 /* RDF resources (URIs and bNodes) */ 284 285 RDF_Node * rdfstore_resource_new( unsigned char * identifier, int len, int type ); 286 RDF_Node * rdfstore_resource_new_from_qname( unsigned char * namespace, int nsl, unsigned char * localname, int lnl, int type ); 287 RDF_Node * rdfstore_resource_clone( RDF_Node * node ); 288 unsigned char * rdfstore_resource_get_label( RDF_Node * node, int * len ); 289 unsigned char * rdfstore_resource_to_string( RDF_Node * node, int * len ); 290 unsigned char * rdfstore_resource_get_digest( RDF_Node * node, int * len ); 291 int rdfstore_resource_equals( RDF_Node * node1, RDF_Node * node2 ); 292 int rdfstore_resource_set_uri( RDF_Node * node, unsigned char * identifier, int len ); 293 unsigned char * rdfstore_resource_get_uri( RDF_Node * node, int * len ); 294 int rdfstore_resource_is_anonymous( RDF_Node * node ); 295 int rdfstore_resource_is_bnode( RDF_Node * node ); 296 unsigned char * rdfstore_resource_get_namespace( RDF_Node * node, int * len ); 297 unsigned char * rdfstore_resource_get_localname( RDF_Node * node, int * len ); 298 unsigned char * rdfstore_resource_get_bnode( RDF_Node * node, int * len ); 299 unsigned char * rdfstore_resource_get_nodeid( RDF_Node * node, int * len ); 300 int rdfstore_resource_free( RDF_Node * node ); 301 void rdfstore_resource_dump( RDF_Node * node ); 302 int rdfstore_resource_set_model( RDF_Node * node, rdfstore * model ); /* for resource centric API ala Jena */ 303 int rdfstore_resource_reset_model( RDF_Node * node ); 304 rdfstore * rdfstore_resource_get_model( RDF_Node * node ); 305 306 /* RDF statements */ 307 308 RDF_Statement * rdfstore_statement_new( RDF_Node * s, RDF_Node * p, RDF_Node * o, RDF_Node * c, RDF_Node * node, int isreified ); 309 RDF_Statement * rdfstore_statement_clone( RDF_Statement * st ); 310 unsigned char * rdfstore_statement_get_label( RDF_Statement * st, int * len ); 311 unsigned char * rdfstore_statement_to_string( RDF_Statement * st, int * len ); 312 unsigned char * rdfstore_statement_get_digest( RDF_Statement * st, int * len ); 313 int rdfstore_statement_equals( RDF_Statement * st1, RDF_Statement * st2 ); 314 int rdfstore_statement_isreified( RDF_Statement * st ); 315 RDF_Node * rdfstore_statement_get_subject( RDF_Statement * st ); 316 int rdfstore_statement_set_subject( RDF_Statement * st, RDF_Node * s ); 317 RDF_Node * rdfstore_statement_get_predicate( RDF_Statement * st ); 318 int rdfstore_statement_set_predicate( RDF_Statement * st, RDF_Node * p ); 319 RDF_Node * rdfstore_statement_get_object( RDF_Statement * st ); 320 int rdfstore_statement_set_object( RDF_Statement * st, RDF_Node * o ); 321 RDF_Node * rdfstore_statement_get_context( RDF_Statement * st ); 322 int rdfstore_statement_set_context( RDF_Statement * st, RDF_Node * c ); 323 RDF_Node * rdfstore_statement_get_node( RDF_Statement * st ); 324 int rdfstore_statement_set_node( RDF_Statement * st, RDF_Node * node ); 325 int rdfstore_statement_free( RDF_Statement * st ); 326 void rdfstore_statement_dump( RDF_Statement * st ); 327 int rdfstore_statement_set_model( RDF_Statement * st, rdfstore * model ); /* for resource centric API ala Jena */ 328 int rdfstore_statement_reset_model( RDF_Statement * st ); 329 rdfstore * rdfstore_statement_get_model( RDF_Statement * st ); 330 331 /* RDF_Triple_Pattern related */ 332 RDF_Triple_Pattern * rdfstore_triple_pattern_new(); 333 RDF_Triple_Pattern_Part * rdfstore_triple_pattern_add_subject( RDF_Triple_Pattern * tp, RDF_Node * node ); 334 int rdfstore_triple_pattern_set_subjects_operator( RDF_Triple_Pattern * tp, int op ); 335 RDF_Triple_Pattern_Part * rdfstore_triple_pattern_add_predicate( RDF_Triple_Pattern * tp, RDF_Node * node ); 336 int rdfstore_triple_pattern_set_predicates_operator( RDF_Triple_Pattern * tp, int op ); 337 RDF_Triple_Pattern_Part * rdfstore_triple_pattern_add_object( RDF_Triple_Pattern * tp, RDF_Node * node ); 338 int rdfstore_triple_pattern_set_objects_operator( RDF_Triple_Pattern * tp, int op ); 339 RDF_Triple_Pattern_Part * rdfstore_triple_pattern_add_context( RDF_Triple_Pattern * tp, RDF_Node * node ); 340 int rdfstore_triple_pattern_set_contexts_operator( RDF_Triple_Pattern * tp, int op ); 341 RDF_Triple_Pattern_Part * rdfstore_triple_pattern_add_lang( RDF_Triple_Pattern * tp, char * lang ); 342 int rdfstore_triple_pattern_set_langs_operator( RDF_Triple_Pattern * tp, int op ); 343 RDF_Triple_Pattern_Part * rdfstore_triple_pattern_add_datatype( RDF_Triple_Pattern * tp, char * dt, int len ); 344 int rdfstore_triple_pattern_set_datatypes_operator( RDF_Triple_Pattern * tp, int op ); 345 RDF_Triple_Pattern_Part * rdfstore_triple_pattern_add_word( RDF_Triple_Pattern * tp, unsigned char * word, int len ); 346 int rdfstore_triple_pattern_set_words_operator( RDF_Triple_Pattern * tp, int op ); 347 RDF_Triple_Pattern_Part * rdfstore_triple_pattern_add_ranges( RDF_Triple_Pattern * tp, char * num, int len ); /* always do strtol() or strtod() on it */ 348 int rdfstore_triple_pattern_set_ranges_operator( RDF_Triple_Pattern * tp, int op ); 349 int rdfstore_triple_pattern_free( RDF_Triple_Pattern * tp ); 350 void rdfstore_triple_pattern_dump( RDF_Triple_Pattern * tp ); 351 352 /* RDFStore itself API */ 353 int 354 rdfstore_connect ( 355 rdfstore * * me, 356 char * name, 357 int flags, 358 int freetext, 359 int sync, 360 int remote, 361 char * host, 362 int port, 363 /* Callbacks for memory management and error handling. */ 364 void * (* malloc)(size_t s), 365 void (* free)(void * adr), 366 void (* callback)(dbms_cause_t cause, int cnt), 367 void (* error)(char * err, int erx) 368 ); 369 370 char * rdfstore_get_version ( 371 rdfstore * me 372 ); 373 374 int rdfstore_disconnect ( 375 rdfstore * me 376 ); 377 378 int rdfstore_isconnected ( 379 rdfstore * me 380 ); 381 382 int rdfstore_isremote ( 383 rdfstore * me 384 ); 385 386 int rdfstore_if_modified_since ( 387 char * name, 388 char * since, 389 /* Callbacks for memory management and error handling. */ 390 void *(*_mmalloc) (size_t s), 391 void (*_mfree) (void *adr), 392 void (*_mcallback) (dbms_cause_t cause, int cnt), 393 void (*_merror) (char *err, int erx) 394 ); 395 396 int rdfstore_size ( 397 rdfstore * me, 398 unsigned int * size 399 ); 400 401 int rdfstore_contains ( 402 rdfstore * me, 403 RDF_Statement * statement, 404 RDF_Node * given_context 405 ); 406 407 int rdfstore_insert ( 408 rdfstore * me, 409 RDF_Statement * statement, 410 RDF_Node * given_context 411 ); 412 413 int rdfstore_remove ( 414 rdfstore * me, 415 RDF_Statement * statement, 416 RDF_Node * given_context 417 ); 418 419 int rdfstore_set_context ( 420 rdfstore * me, 421 RDF_Node * given_context 422 ); 423 424 int rdfstore_reset_context ( 425 rdfstore * me 426 ); 427 428 RDF_Node * 429 rdfstore_get_context ( 430 rdfstore * me 431 ); 432 433 int rdfstore_set_source_uri ( 434 rdfstore * me, 435 char * uri 436 ); 437 438 int rdfstore_get_source_uri ( 439 rdfstore * me, 440 char * uri 441 ); 442 443 int rdfstore_is_empty ( 444 rdfstore * me 445 ); 446 447 /* return iterator over the result set (even empty if no results) */ 448 rdfstore_iterator * 449 rdfstore_search ( 450 rdfstore * me, 451 RDF_Triple_Pattern * tp, 452 int search_type /* 0=main indexes (subjects, predicates, objects tables) 453 1=RDQL indexes (s_connections, p_connections, o_connections tables) */ 454 ); 455 456 rdfstore_iterator * 457 rdfstore_fetch_object( 458 rdfstore * me, 459 RDF_Node * resource, 460 RDF_Node * given_context 461 ); 462 463 /* return iterator over the whole model content - we could eventually specify a context then it becomes a search in context.... */ 464 rdfstore_iterator * 465 rdfstore_elements ( 466 rdfstore * me 467 ); 468 469 /* Special keys with a special meaning. - should be longer than 4 bytes to 470 * make sure they do not match a unsigned int. 471 */ 472 #define RDFSTORE_INDEXING_VERSION_KEY ("indexing_version") 473 #define RDFSTORE_COUNTER_KEY ("counter") 474 #define RDFSTORE_COUNTER_REMOVED_KEY ("counter_removed") 475 #define RDFSTORE_FREETEXT_KEY ("freetext") 476 #define RDFSTORE_NAME_KEY ("name") 477 #define RDFSTORE_COMPRESSION_KEY ("compression") 478 #define RDFSTORE_COMPRESSION_CONNECTIONS_KEY ("compression_connections") 479 #define RDFSTORE_LASTMODIFIED_KEY ("last_modified") 480 481 #if 0 482 void packInt(uint32_t value, unsigned char *lookup); 483 void unpackInt(unsigned char *value, uint32_t *lookup); 484 #else 485 #define packInt(value,buffer) { assert(sizeof((value)) == sizeof(uint32_t)); *(uint32_t *)(buffer)=htonl((value)); } 486 #define unpackInt(buffer,value) { *(value) = ntohl(*(uint32_t *)(buffer)); } 487 #endif 488 #endif 489