/** * librdf_new_storage - Constructor - create a new librdf_storage object * @world: redland world object * @storage_name: the storage factory name * @name: an identifier for the storage * @options_string: options to initialise storage * * The options are encoded as described in librdf_hash_from_string() * and can be NULL if none are required. * * Return value: a new &librdf_storage object or NULL on failure */ librdf_storage* librdf_new_storage (librdf_world *world, char *storage_name, char *name, char *options_string) { librdf_storage_factory* factory; librdf_hash* options_hash; factory=librdf_get_storage_factory(storage_name); if(!factory) return NULL; options_hash=librdf_new_hash(world, NULL); if(!options_hash) return NULL; if(librdf_hash_open(options_hash, NULL, 0, 1, 1, NULL)) { librdf_free_hash(options_hash); return NULL; } if(librdf_hash_from_string(options_hash, options_string)) { librdf_free_hash(options_hash); return NULL; } return librdf_new_storage_from_factory(world, factory, name, options_hash); }
/* functions implementing storage api */ static int librdf_storage_tstore_init(librdf_storage* storage, const char *name, librdf_hash* options) { librdf_storage_tstore_instance* context=(librdf_storage_tstore_instance*)LIBRDF_CALLOC( librdf_storage_tstore_instance, 1, sizeof(librdf_storage_tstore_instance)); if(!context) { if(options) librdf_free_hash(options); return 1; } librdf_storage_set_instance(storage, context); context->host=librdf_hash_get_del(options, "host"); context->db=librdf_hash_get_del(options, "database"); context->user=librdf_hash_get_del(options, "user"); context->password=librdf_hash_get_del(options, "password"); context->model=librdf_hash_get_del(options, "model"); /* no more options, might as well free them now */ if(options) librdf_free_hash(options); return 0; }
/* functions implementing storage api */ static int librdf_storage_trees_init(librdf_storage* storage, const char *name, librdf_hash* options) { const int index_spo_option = librdf_hash_get_as_boolean(options, "index-spo") > 0; const int index_sop_option = librdf_hash_get_as_boolean(options, "index-sop") > 0; const int index_ops_option = librdf_hash_get_as_boolean(options, "index-ops") > 0; const int index_pso_option = librdf_hash_get_as_boolean(options, "index-pso") > 0; librdf_storage_trees_instance* context=(librdf_storage_trees_instance*)LIBRDF_CALLOC( librdf_storage_trees_instance, 1, sizeof(librdf_storage_trees_instance)); if(!context) { if(options) librdf_free_hash(options); return 1; } librdf_storage_set_instance(storage, context); #ifdef RDF_STORAGE_TREES_WITH_CONTEXTS /* Support contexts if option given */ if (librdf_hash_get_as_boolean(options, "contexts") > 0) { context->contexts=librdf_new_avltree(librdf_storage_trees_graph_compare, librdf_storage_trees_graph_free); } else { context->contexts=NULL; } #endif /* No indexing options given, index all by default */ if (!index_spo_option && !index_sop_option && !index_ops_option && !index_pso_option) { context->index_sop=1; context->index_ops=1; context->index_pso=1; } else { /* spo is always indexed, option just exists so user can * specifically /only/ index spo */ context->index_sop=index_sop_option; context->index_ops=index_ops_option; context->index_pso=index_pso_option; } context->graph = librdf_storage_trees_graph_new(storage, NULL); /* no more options, might as well free them now */ if(options) librdf_free_hash(options); return 0; }
int librdf_raptor_free_bnode_hash(librdf_world* world) { if(world->bnode_hash) { librdf_free_hash(world->bnode_hash); world->bnode_hash = NULL; } return 0; }
/** * librdf_finish_uri: * @world: redland world object * * INTERNAL - Terminate the uri module. * **/ void librdf_finish_uri(librdf_world *world) { if (world->uris_hash) { librdf_hash_close(world->uris_hash); if(world->uris_hash_allocated_here) librdf_free_hash(world->uris_hash); } }
/** * librdf_new_storage_from_factory - Constructor - create a new librdf_storage object * @world: redland world object * @factory: the factory to use to construct the storage * @name: name to use for storage * @options: &librdf_hash of options to initialise storage * * If the options are present, they become owned by the storage * and should no longer be used. * * Return value: a new &librdf_storage object or NULL on failure */ librdf_storage* librdf_new_storage_from_factory (librdf_world *world, librdf_storage_factory* factory, char *name, librdf_hash* options) { librdf_storage* storage; LIBRDF_ASSERT_OBJECT_POINTER_RETURN_VALUE(factory, librdf_storage_factory, NULL); if(!factory) { librdf_free_hash(options); return NULL; } storage=(librdf_storage*)LIBRDF_CALLOC(librdf_storage, 1, sizeof(librdf_storage)); if(!storage) { librdf_free_hash(options); return NULL; } storage->world=world; storage->context=(char*)LIBRDF_CALLOC(librdf_storage_context, 1, factory->context_length); if(!storage->context) { librdf_free_hash(options); librdf_free_storage(storage); return NULL; } storage->factory=factory; if(factory->init(storage, name, options)) { librdf_free_storage(storage); return NULL; } storage->usage=1; return storage; }
/** * librdf_finish_raptor: * @world: librdf_world object * * INTERNAL - Terminate the raptor library. * * Frees the raptor library resources unless a raptor instance was provided * externally via librdf_world_set_raptor() (and using raptor v2 APIs) prior * to librdf_init_raptor(). **/ void librdf_finish_raptor(librdf_world* world) { if(world->raptor_world_ptr && world->raptor_world_allocated_here) { raptor_free_world(world->raptor_world_ptr); world->raptor_world_ptr = NULL; } if(world->bnode_hash) librdf_free_hash(world->bnode_hash); }
/** * librdf_finish_uri: * @world: redland world object * * INTERNAL - Terminate the uri module. * **/ void librdf_finish_uri(librdf_world *world) { #ifndef LIBRDF_USE_RAPTOR_URI if (world->uris_hash) { librdf_hash_close(world->uris_hash); if(world->uris_hash_allocated_here) librdf_free_hash(world->uris_hash); } #endif }
static void test_all(const char *program) { librdf_hash *h; int num_test_hash_types, i, j; //const char *test_hash_types[]={"bdb", "tokyodb", "memory", NULL}; const char *test_hash_types[]={"tokyodb"}; librdf_world *world; world=librdf_new_world(); librdf_world_open(world); num_test_hash_types = sizeof(test_hash_types)/sizeof(const char*); for(i=0; i < num_test_hash_types; i++) { char db_name[100]; const char *type = test_hash_types[i]; fprintf(stdout, "Trying to create new %s hash\n", type); h=librdf_new_hash(world, type); if(!h) { fprintf(stderr, "Failed to create new hash type '%s' '%s'\n", program, type); continue; } sprintf(db_name, "test_%s_%s", type, DB_NAME_SUFFIX); if(librdf_hash_open(h, db_name, 0644, 1, 1, NULL)) { fprintf(stderr, "Failed to open new hash type '%s' '%s'\n", program, type); continue; } for (j=1; j<=STRESS_TEST_HASH_ITERATION; j++) { fprintf(stdout, "test_hash_funtionality iteration.. %d\n", j); test_hash_funtionality(world, h); } librdf_hash_close(h); fprintf(stdout, "Freeing hash: %s\n", program); librdf_free_hash(h); } librdf_free_world(world); }
static int test_hash_funtionality(librdf_world *world, librdf_hash *h) { librdf_hash *ch; const char *test_put_array[]={ "colour","yellow", "age", "new", "size", "large", "colour", "green", "fruit", "banana", "colour", "yellow", }; const char *test_delete_array[]={ "invalidkey", "invalidvalue", "colour", "yellow", "colour", "aaaaaaaaaaaaainvalidvalue", "colour", "zzzzzzzzzzzzzinvalidvalue", "colour", NULL, "fruit", NULL, "size", "large", "age", "new", }; const char *test_get_values_for_key="colour"; int len, i; for (i=1; i<=STRESS_TEST_PUT_ITERATION; i++) { fprintf(stdout, "put iteration.. %d\n", i); /* Test put */ len = sizeof(test_put_array)/sizeof(const char*); test_put(world, h, test_put_array, len); } fprintf(stdout, "total values: %d.", librdf_hash_values_count(h)); /* Test get all keys only */ fprintf(stdout, "all hash keys:"); librdf_hash_print_keys(h, stdout); fputc('\n', stdout); /* Test get all values of given key */ fprintf(stdout, "all values of key '%s'=", test_get_values_for_key); librdf_hash_print_values(h, test_get_values_for_key, stdout); fputc('\n', stdout); /* Test cloning hash */ fprintf(stdout, "cloning hash\n"); ch = librdf_new_hash_from_hash(h); if(ch) { fprintf(stdout, "clone success. values count %d\n", librdf_hash_values_count(ch)); fprintf(stdout, "resulting: "); librdf_hash_print(ch, stdout); fputc('\n', stdout); librdf_hash_close(ch); librdf_free_hash(ch); } else { fprintf(stderr, "Failed to clone hash\n"); } /* Test delete */ len = sizeof(test_delete_array)/sizeof(const char*); test_delete(world, h, test_delete_array, len); /* Test string related features */ test_string_manipulation(world, h); return 0; }
/* functions implementing storage api */ static int librdf_storage_cassandra_init(librdf_storage* storage, const char *name, librdf_hash* options) { char *name_copy; librdf_storage_cassandra_instance* context; if(!name) { if(options) librdf_free_hash(options); return 1; } context = LIBRDF_CALLOC(librdf_storage_cassandra_instance*, 1, sizeof(*context)); if(!context) { if(options) librdf_free_hash(options); return 1; } librdf_storage_set_instance(storage, context); context->storage = storage; context->name_len = strlen(name); // context->transaction = 0; name_copy = LIBRDF_MALLOC(char*, context->name_len + 1); if(!name_copy) { if(options) librdf_free_hash(options); return 1; } strcpy(name_copy, name); context->name = name_copy; // Add options here. /* no more options, might as well free them now */ if(options) librdf_free_hash(options); // FIXME: Hard-coded; context->session = cass_session_new(); context->cluster = cass_cluster_new(); cass_cluster_set_contact_points(context->cluster, name); CassFuture* future = cass_session_connect(context->session, context->cluster); CassError rc = cass_future_error_code(future); if (rc != CASS_OK) { fprintf(stderr, "Cassandra: %s\n", cass_error_desc(rc)); cass_cluster_free(context->cluster); cass_session_free(context->session); free(context->name); free(context); return 1; } cass_future_free(future); return 0; }
/* functions implementing storage api */ static int librdf_storage_file_init(librdf_storage* storage, const char *name, librdf_hash* options) { char *name_copy; char *contexts; int rc = 1; int is_uri = !strcmp(storage->factory->name, "uri"); const char *format_name = (is_uri ? "guess" : "rdfxml"); librdf_storage_file_instance* context; context = (librdf_storage_file_instance*)LIBRDF_CALLOC(librdf_storage_file_instance, 1, sizeof(librdf_storage_file_instance)); if(!context) goto done; librdf_storage_set_instance(storage, context); /* Cannot save contexts in a file; pass everything else on */ contexts = librdf_hash_get_del(options, "contexts"); if(contexts) LIBRDF_FREE(cstring, contexts); context->format_name = librdf_hash_get_del(options, "format"); if(context->format_name) { /* for 'file' and 'uri' storage, check this is a valid parser * for 'file' storage, also check this is a valid serializer */ if(!librdf_parser_check_name(storage->world, context->format_name) || (!is_uri && !librdf_serializer_check_name(storage->world, context->format_name))) { librdf_log(storage->world, 0, LIBRDF_LOG_WARN, LIBRDF_FROM_STORAGE, NULL, "Ignoring storage %s format option '%s' - using default format '%s'", storage->factory->name, context->format_name, format_name); LIBRDF_FREE(cstring, context->format_name); context->format_name = NULL; } if(context->format_name) format_name = context->format_name; } if(is_uri) context->uri = librdf_new_uri(storage->world, (const unsigned char*)name); else { context->name_len = strlen(name); name_copy = (char*)LIBRDF_MALLOC(cstring, context->name_len+1); if(!name_copy) goto done; strcpy(name_copy,name); context->name = name_copy; context->uri = librdf_new_uri_from_filename(storage->world, context->name); } context->storage = librdf_new_storage_with_options(storage->world, NULL, NULL, options); if(!context->storage) goto done; context->model = librdf_new_model(storage->world, context->storage, NULL); if(!context->model) goto done; if(is_uri || !access((const char*)context->name, F_OK)) { librdf_parser *parser; parser = librdf_new_parser(storage->world, format_name, NULL, NULL); if(!parser) { rc = 1; goto done; } librdf_parser_parse_into_model(parser, context->uri, NULL, context->model); librdf_free_parser(parser); } context->changed = 0; rc = 0; done: /* no more options, might as well free them now */ if(options) librdf_free_hash(options); return rc; }
int main(int argc, char *argv[]) { librdf_world* world; librdf_parser* parser; librdf_serializer* serializer; librdf_storage *storage; librdf_model* model; librdf_node *source, *arc, *target, *node; librdf_node *subject, *predicate, *object; librdf_node* context_node=NULL; librdf_stream* stream; librdf_iterator* iterator; librdf_uri *uri; librdf_uri *base_uri=NULL; librdf_query *query; librdf_query_results *results; librdf_hash *options; int count; int rc; int transactions=0; const char* storage_name; const char* storage_options; const char* context; const char* identifier; const char* results_format; librdf_statement* statement=NULL; char* query_cmd=NULL; char* s; /* * Initialize */ storage_name="virtuoso"; results_format="xml"; context=DEFAULT_CONTEXT; identifier=DEFAULT_IDENTIFIER; /* * Get connection options */ if(argc == 2 && argv[1][0] != '\0') storage_options=argv[1]; else if((s=getenv ("VIRTUOSO_STORAGE_OPTIONS")) != NULL) storage_options=s; else storage_options=DEFAULT_STORAGE_OPTIONS; world=librdf_new_world(); librdf_world_set_logger(world, world, log_handler); librdf_world_open(world); options=librdf_new_hash(world, NULL); librdf_hash_open(options, NULL, 0, 1, 1, NULL); librdf_hash_put_strings(options, "contexts", "yes"); transactions=1; librdf_hash_from_string(options, storage_options); storage=librdf_new_storage_with_options(world, storage_name, identifier, options); if(!storage) { fprintf(stderr, ": Failed to open %s storage '%s'\n", storage_name, identifier); return(1); } model=librdf_new_model(world, storage, NULL); if(!model) { fprintf(stderr, ": Failed to create model\n"); return(1); } if(transactions) librdf_model_transaction_start(model); /* Do this or gcc moans */ stream=NULL; iterator=NULL; parser=NULL; serializer=NULL; source=NULL; arc=NULL; target=NULL; subject=NULL; predicate=NULL; object=NULL; uri=NULL; node=NULL; query=NULL; results=NULL; context_node=librdf_new_node_from_uri_string(world, (const unsigned char *)context); /**** Test 1 *******/ startTest(1, " Remove all triples in <%s> context\n", context); { rc=librdf_model_context_remove_statements(model, context_node); if(rc) endTest(0, " failed to remove context triples from the graph\n"); else endTest(1, " removed context triples from the graph\n"); } /**** Test 2 *******/ startTest(2, " Add triples to <%s> context\n", context); { rc=0; rc |= add_triple(world, context_node, model, "aa", "bb", "cc"); rc |= add_triple(world, context_node, model, "aa", "bb1", "cc"); rc |= add_triple(world, context_node, model, "aa", "a2", "_:cc"); rc |= add_triple_typed(world, context_node, model, "aa", "a2", "cc"); rc |= add_triple_typed(world, context_node, model, "mm", "nn", "Some long literal with language@en"); rc |= add_triple_typed(world, context_node, model, "oo", "pp", "12345^^<http://www.w3.org/2001/XMLSchema#int>"); if(rc) endTest(0, " failed add triple\n"); else endTest(1, " add triple to context\n"); } /**** Test 3 *******/ startTest(3, " Print all triples in <%s> context\n", context); { raptor_iostream* iostr = raptor_new_iostream_to_file_handle(librdf_world_get_raptor(world), stdout); librdf_model_write(model, iostr); raptor_free_iostream(iostr); endTest(1, "\n"); } /***** Test 4 *****/ startTest(4, " Count of triples in <%s> context\n", context); { count=librdf_model_size(model); if(count >= 0) endTest(1, " graph has %d triples\n", count); else endTest(0, " graph has unknown number of triples\n"); } /***** Test 5 *****/ startTest(5, " Exec: ARC aa bb \n"); { subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa"); predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb"); node=librdf_model_get_target(model, subject, predicate); librdf_free_node(subject); librdf_free_node(predicate); if(!node) { endTest(0, " Failed to get arc\n"); } else { print_node(stdout, node); librdf_free_node(node); endTest(1, "\n"); } } /***** Test 6 *****/ startTest(6, " Exec: ARCS aa cc \n"); { subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa"); object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc"); iterator=librdf_model_get_arcs(model, subject, object); librdf_free_node(subject); librdf_free_node(object); if(!iterator) { endTest(0, " Failed to get arcs\n"); } else { print_nodes(stdout, iterator); endTest(1, "\n"); } } /***** Test 7 *****/ startTest(7, " Exec: ARCS-IN cc \n"); { object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc"); iterator=librdf_model_get_arcs_in(model, object); librdf_free_node(object); if(!iterator) { endTest(0, " Failed to get arcs in\n"); } else { int ok=1; count=0; while(!librdf_iterator_end(iterator)) { context_node=(librdf_node*)librdf_iterator_get_context(iterator); node=(librdf_node*)librdf_iterator_get_object(iterator); /*returns SHARED pointer */ if(!node) { ok=0; endTest(ok, " librdf_iterator_get_next returned NULL\n"); break; } fputs("Matched arc: ", stdout); librdf_node_print(node, stdout); if(context_node) { fputs(" with context ", stdout); librdf_node_print(context_node, stdout); } fputc('\n', stdout); count++; librdf_iterator_next(iterator); } librdf_free_iterator(iterator); endTest(ok, " matching arcs: %d\n", count); } } /***** Test 8 *****/ startTest(8, " Exec: ARCS-OUT aa \n"); { subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa"); iterator=librdf_model_get_arcs_out(model, subject); librdf_free_node(subject); if(!iterator) endTest(0, " Failed to get arcs out\n"); else { int ok=1; count=0; while(!librdf_iterator_end(iterator)) { context_node=(librdf_node*)librdf_iterator_get_context(iterator); node=(librdf_node*)librdf_iterator_get_object(iterator); if(!node) { ok=0; endTest(ok, " librdf_iterator_get_next returned NULL\n"); break; } fputs("Matched arc: ", stdout); librdf_node_print(node, stdout); if(context_node) { fputs(" with context ", stdout); librdf_node_print(context_node, stdout); } fputc('\n', stdout); count++; librdf_iterator_next(iterator); } librdf_free_iterator(iterator); endTest(ok, " matching arcs: %d\n", count); } } /***** Test 9 *****/ startTest(9, " Exec: CONTAINS aa bb1 cc \n"); { subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa"); predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb1"); object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc"); statement=librdf_new_statement(world); librdf_statement_set_subject(statement, subject); librdf_statement_set_predicate(statement, predicate); librdf_statement_set_object(statement, object); if(librdf_model_contains_statement(model, statement)) endTest(1, " the graph contains the triple\n"); else endTest(0, " the graph does not contain the triple\n"); librdf_free_statement(statement); } /***** Test 10 *****/ startTest(10, " Exec: FIND aa - - \n"); { subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa"); statement=librdf_new_statement(world); librdf_statement_set_subject(statement, subject); stream=librdf_model_find_statements_in_context(model, statement, context_node); if(!stream) { endTest(0, " FIND returned no results (NULL stream)\n"); } else { librdf_node* ctxt_node=NULL; int ok=1; count=0; while(!librdf_stream_end(stream)) { librdf_statement *stmt=librdf_stream_get_object(stream); ctxt_node=(librdf_node*)librdf_stream_get_context(stream); if(!stmt) { ok=0; endTest(ok, " librdf_stream_next returned NULL\n"); break; } fputs("Matched triple: ", stdout); librdf_statement_print(stmt, stdout); if(context) { fputs(" with context ", stdout); librdf_node_print(ctxt_node, stdout); } fputc('\n', stdout); count++; librdf_stream_next(stream); } librdf_free_stream(stream); endTest(ok, " matching triples: %d\n", count); } librdf_free_statement(statement); } /***** Test 11 *****/ startTest(11, " Exec: HAS-ARC-IN cc bb \n"); { predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb"); object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc"); if(librdf_model_has_arc_in(model, object, predicate)) endTest(1, " the graph contains the arc\n"); else endTest(0, " the graph does not contain the arc\n"); librdf_free_node(predicate); librdf_free_node(object); } /***** Test 12 *****/ startTest(12, " Exec: HAS-ARC-OUT aa bb \n"); { subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa"); predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb"); if(librdf_model_has_arc_out(model, subject, predicate)) endTest(1, " the graph contains the arc\n"); else endTest(0, " the graph does not contain the arc\n"); librdf_free_node(predicate); librdf_free_node(subject); } /***** Test 13 *****/ startTest(13, " Exec: SOURCE aa cc \n"); { predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb"); object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc"); node=librdf_model_get_source(model, predicate, object); librdf_free_node(predicate); librdf_free_node(object); if(!node) { endTest(0, " Failed to get source\n"); } else { print_node(stdout, node); librdf_free_node(node); endTest(1, "\n"); } } /***** Test 14 *****/ startTest(14, " Exec: SOURCES bb cc \n"); { predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb"); object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc"); iterator=librdf_model_get_sources(model, predicate, object); librdf_free_node(predicate); librdf_free_node(object); if(!iterator) { endTest(0, " Failed to get sources\n"); } else { print_nodes(stdout, iterator); endTest(1, "\n"); } } /***** Test 15 *****/ startTest(15, " Exec: TARGET aa bb \n"); { subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa"); predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb"); node=librdf_model_get_target(model, subject, predicate); librdf_free_node(subject); librdf_free_node(predicate); if(!node) { endTest(0, " Failed to get target\n"); } else { print_node(stdout, node); librdf_free_node(node); endTest(1, "\n"); } } /***** Test 16 *****/ startTest(16, " Exec: TARGETS aa bb \n"); { subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa"); predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb"); iterator=librdf_model_get_targets(model, subject, predicate); librdf_free_node(subject); librdf_free_node(predicate); if(!iterator) { endTest(0, " Failed to get targets\n"); } else { print_nodes(stdout, iterator); endTest(1, "\n"); } } /***** Test 17 *****/ startTest(17, " Exec: REMOVE aa bb1 cc \n"); { subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa"); predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb1"); object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc"); statement=librdf_new_statement(world); librdf_statement_set_subject(statement, subject); librdf_statement_set_predicate(statement, predicate); librdf_statement_set_object(statement, object); if(librdf_model_context_remove_statement(model, context_node, statement)) endTest(0, " failed to remove triple from the graph\n"); else endTest(1, " removed triple from the graph\n"); librdf_free_statement(statement); } /***** Test 18 *****/ query_cmd=(char *)"CONSTRUCT {?s ?p ?o} FROM <http://red> WHERE {?s ?p ?o}"; startTest(18, " Exec: QUERY \"%s\" \n", query_cmd); { query=librdf_new_query(world, (char *)"vsparql", NULL, (const unsigned char *)query_cmd, NULL); if(!(results=librdf_model_query_execute(model, query))) { endTest(0, " Query of model with '%s' failed\n", query_cmd); librdf_free_query(query); query=NULL; } else { stream=librdf_query_results_as_stream(results); if(!stream) { endTest(0, " QUERY returned no results (NULL stream)\n"); } else { librdf_node* ctxt=NULL; count=0; while(!librdf_stream_end(stream)) { librdf_statement *stmt=librdf_stream_get_object(stream); /*returns SHARED pointer */ ctxt=(librdf_node*)librdf_stream_get_context(stream); if(!stmt) { endTest(0, " librdf_stream_next returned NULL\n"); break; } fputs("Matched triple: ", stdout); librdf_statement_print(stmt, stdout); if(ctxt) { fputs(" with context ", stdout); librdf_node_print(ctxt, stdout); } fputc('\n', stdout); count++; librdf_stream_next(stream); } librdf_free_stream(stream); endTest(1, " matching triples: %d\n", count); librdf_free_query_results(results); } } librdf_free_query(query); } /***** Test 19 *****/ query_cmd=(char *)"SELECT * WHERE {graph <http://red> { ?s ?p ?o }}"; startTest(19, " Exec1: QUERY_AS_BINDINGS \"%s\" \n", query_cmd); { query=librdf_new_query(world, (char *)"vsparql", NULL, (const unsigned char *)query_cmd, NULL); if(!(results=librdf_model_query_execute(model, query))) { endTest(0, " Query of model with '%s' failed\n", query_cmd); librdf_free_query(query); query=NULL; } else { raptor_iostream *iostr; librdf_query_results_formatter *formatter; fprintf(stderr, "**: Formatting query result as '%s':\n", results_format); iostr = raptor_new_iostream_to_file_handle(librdf_world_get_raptor(world), stdout); formatter = librdf_new_query_results_formatter2(results, results_format, NULL /* mime type */, NULL /* format_uri */); base_uri = librdf_new_uri(world, (const unsigned char*)"http://example.org/"); librdf_query_results_formatter_write(iostr, formatter, results, base_uri); librdf_free_query_results_formatter(formatter); raptor_free_iostream(iostr); librdf_free_uri(base_uri); endTest(1, "\n"); librdf_free_query_results(results); } librdf_free_query(query); } /***** Test 20 *****/ query_cmd=(char *)"SELECT * WHERE {graph <http://red> { ?s ?p ?o }}"; startTest(20, " Exec2: QUERY_AS_BINDINGS \"%s\" \n", query_cmd); { query=librdf_new_query(world, (char *)"vsparql", NULL, (const unsigned char *)query_cmd, NULL); if(!(results=librdf_model_query_execute(model, query))) { endTest(0, " Query of model with '%s' failed\n", query_cmd); librdf_free_query(query); query=NULL; } else { if(print_query_results(world, model, results)) endTest(0, "\n"); else endTest(1, "\n"); librdf_free_query_results(results); } librdf_free_query(query); } getTotal(); if(transactions) librdf_model_transaction_commit(model); librdf_free_node(context_node); librdf_free_node(context_node); librdf_free_hash(options); librdf_free_model(model); librdf_free_storage(storage); librdf_free_world(world); #ifdef LIBRDF_MEMORY_DEBUG librdf_memory_report(stderr); #endif /* keep gcc -Wall happy */ return(0); }