static void librdf_stream_from_node_iterator_finished(void* context) { librdf_stream_from_node_iterator_stream_context* scontext=(librdf_stream_from_node_iterator_stream_context*)context; if(scontext->iterator) librdf_free_iterator(scontext->iterator); if(scontext->current) { switch(scontext->field) { case LIBRDF_STATEMENT_SUBJECT: librdf_statement_set_subject(scontext->current, NULL); break; case LIBRDF_STATEMENT_PREDICATE: librdf_statement_set_predicate(scontext->current, NULL); break; case LIBRDF_STATEMENT_OBJECT: librdf_statement_set_object(scontext->current, NULL); break; case LIBRDF_STATEMENT_ALL: default: librdf_log(scontext->iterator->world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_STREAM, NULL, "Illegal statement field %d seen", scontext->field); } librdf_free_statement(scontext->current); } LIBRDF_FREE(librdf_stream_from_node_iterator_stream_context, scontext); }
int add_triple_typed(librdf_world *world, librdf_node *context, librdf_model* model, const char *s, const char *p, const char *o) { librdf_node *subject, *predicate, *object; librdf_statement* statement=NULL; int rc; if(librdf_heuristic_is_blank_node(s)) subject=librdf_new_node_from_blank_identifier(world, (const unsigned char *)librdf_heuristic_get_blank_node(s)); else subject=librdf_new_node_from_uri_string(world, (const unsigned char *)s); predicate=librdf_new_node_from_uri_string(world, (const unsigned char *)p); if(librdf_heuristic_is_blank_node(o)) object=librdf_new_node_from_blank_identifier(world, (const unsigned char *)librdf_heuristic_get_blank_node(o)); else object=librdf_new_node_from_literal(world, (const unsigned char *)o, NULL, 0); statement=librdf_new_statement(world); librdf_statement_set_subject(statement, subject); librdf_statement_set_predicate(statement, predicate); librdf_statement_set_object(statement, object); rc=librdf_model_context_add_statement(model, context, statement); librdf_free_statement(statement); return rc; }
template <> Statement::Statement (TConstStatement1 & a) { librdf_statement *st; st = librdf_new_statement (rdf_world::get_world ()); cerr << "template statement: sub:" << a.s << " pred:" << a.p << " obj:" << a.o << endl; librdf_statement_set_subject (st, node_create_from_uri (a.s.get_uri ())); librdf_statement_set_predicate (st, node_create_from_uri (a.p.get_uri ())); //librdf_statement_set_object (st, node_create_from_uri (a.o.get_uri ())); librdf_statement_set_object (st,node_create_from_string (a.o)); librdf_model_add_statement (rdf_world::get_model (), st); }
static void* librdf_stream_from_node_iterator_get_statement(void* context, int flags) { librdf_stream_from_node_iterator_stream_context* scontext=(librdf_stream_from_node_iterator_stream_context*)context; librdf_node* node; switch(flags) { case LIBRDF_ITERATOR_GET_METHOD_GET_OBJECT: if(!(node=(librdf_node*)librdf_iterator_get_object(scontext->iterator))) return NULL; /* The node object above is shared, no need to free it before * assigning to the statement, which is also shared, and * return to the user. */ switch(scontext->field) { case LIBRDF_STATEMENT_SUBJECT: librdf_statement_set_subject(scontext->current, node); break; case LIBRDF_STATEMENT_PREDICATE: librdf_statement_set_predicate(scontext->current, node); break; case LIBRDF_STATEMENT_OBJECT: librdf_statement_set_object(scontext->current, node); break; case LIBRDF_STATEMENT_ALL: default: librdf_log(scontext->iterator->world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_STREAM, NULL, "Illegal statement field %d seen", scontext->field); return NULL; } return scontext->current; case LIBRDF_ITERATOR_GET_METHOD_GET_CONTEXT: return librdf_iterator_get_context(scontext->iterator); default: librdf_log(scontext->iterator->world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_STREAM, NULL, "Unknown iterator method flag %d", flags); return NULL; } }
static void librdf_storage_stream_to_node_iterator_finished(void* iterator) { librdf_storage_stream_to_node_iterator_context* context=(librdf_storage_stream_to_node_iterator_context*)iterator; librdf_statement *partial_statement=context->partial_statement; /* make sure librdf_free_statement() doesn't free anything here */ if(partial_statement) { librdf_statement_set_subject(partial_statement, NULL); librdf_statement_set_predicate(partial_statement, NULL); librdf_statement_set_object(partial_statement, NULL); librdf_free_statement(partial_statement); } if(context->stream) librdf_free_stream(context->stream); if(context->storage) librdf_storage_remove_reference(context->storage); LIBRDF_FREE(librdf_storage_stream_to_node_iterator_context, context); }
int main(int argc, char *argv[]) { librdf_statement *statement, *statement2; int size, size2; const char *program=librdf_basename((const char*)argv[0]); char *s, *buffer; librdf_world *world; raptor_iostream *iostr; world=librdf_new_world(); librdf_world_open(world); iostr = raptor_new_iostream_to_file_handle(world->raptor_world_ptr, stdout); fprintf(stdout, "%s: Creating statement\n", program); statement=librdf_new_statement(world); fprintf(stdout, "%s: Empty statement: ", program); librdf_statement_write(statement, iostr); fputs("\n", stdout); librdf_statement_set_subject(statement, librdf_new_node_from_uri_string(world, (const unsigned char*)"http://purl.org/net/dajobe/")); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(world, (const unsigned char*)"http://purl.org/dc/elements/1.1/#Creator")); librdf_statement_set_object(statement, librdf_new_node_from_literal(world, (const unsigned char*)"Dave Beckett", NULL, 0)); fprintf(stdout, "%s: Resulting statement: ", program); librdf_statement_write(statement, iostr); fputs("\n", stdout); size = librdf_statement_encode2(world, statement, NULL, 0); fprintf(stdout, "%s: Encoding statement requires %d bytes\n", program, size); buffer=(char*)LIBRDF_MALLOC(cstring, size); fprintf(stdout, "%s: Encoding statement in buffer\n", program); size2 = librdf_statement_encode2(world, statement, (unsigned char*)buffer, size); if(size2 != size) { fprintf(stdout, "%s: Encoding statement used %d bytes, expected it to use %d\n", program, size2, size); return(1); } fprintf(stdout, "%s: Creating new statement\n", program); statement2=librdf_new_statement(world); fprintf(stdout, "%s: Decoding statement from buffer\n", program); if(!librdf_statement_decode2(world, statement2, NULL, (unsigned char*)buffer, size)) { fprintf(stdout, "%s: Decoding statement failed\n", program); return(1); } LIBRDF_FREE(cstring, buffer); fprintf(stdout, "%s: New statement is: ", program); librdf_statement_write(statement, iostr); fputs("\n", stdout); fprintf(stdout, "%s: Freeing statements\n", program); librdf_free_statement(statement2); librdf_free_statement(statement); librdf_free_world(world); /* keep gcc -Wall happy */ return(0); }
/* * librdf_parser_raptor_new_statement_handler - helper callback function for raptor RDF when a new triple is asserted * @context: context for callback * @statement: raptor_statement * * Adds the statement to the list of statements. */ static void librdf_parser_raptor_new_statement_handler(void *context, raptor_statement *rstatement) { librdf_parser_raptor_stream_context* scontext=(librdf_parser_raptor_stream_context*)context; librdf_node* node; librdf_statement* statement; librdf_world* world=scontext->pcontext->parser->world; int rc; statement=librdf_new_statement(world); if(!statement) return; if(rstatement->subject->type == RAPTOR_TERM_TYPE_BLANK) { node = librdf_new_node_from_blank_identifier(world, (const unsigned char*)rstatement->subject->value.blank.string); } else if (rstatement->subject->type == RAPTOR_TERM_TYPE_URI) { node = librdf_new_node_from_uri(world, (librdf_uri*)rstatement->subject->value.uri); } else { librdf_log(world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_PARSER, NULL, "Unknown Raptor subject identifier type %d", rstatement->subject->type); librdf_free_statement(statement); return; } if(!node) { librdf_log(world, 0, LIBRDF_LOG_FATAL, LIBRDF_FROM_PARSER, NULL, "Cannot create subject node"); librdf_free_statement(statement); return; } librdf_statement_set_subject(statement, node); if(rstatement->predicate->type == RAPTOR_TERM_TYPE_URI) { node = librdf_new_node_from_uri(world, (librdf_uri*)rstatement->predicate->value.uri); } else { librdf_log(world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_PARSER, NULL, "Unknown Raptor predicate identifier type %d", rstatement->predicate->type); librdf_free_statement(statement); return; } if(!node) { librdf_log(world, 0, LIBRDF_LOG_FATAL, LIBRDF_FROM_PARSER, NULL, "Cannot create predicate node"); librdf_free_statement(statement); return; } librdf_statement_set_predicate(statement, node); if(rstatement->object->type == RAPTOR_TERM_TYPE_LITERAL) { node = librdf_new_node_from_typed_literal(world, rstatement->object->value.literal.string, (const char *)rstatement->object->value.literal.language, (librdf_uri*)rstatement->object->value.literal.datatype); } else if(rstatement->object->type == RAPTOR_TERM_TYPE_BLANK) { node = librdf_new_node_from_blank_identifier(world, rstatement->object->value.blank.string); } else if(rstatement->object->type == RAPTOR_TERM_TYPE_URI) { node = librdf_new_node_from_uri(world, (librdf_uri*)rstatement->object->value.uri); } else { librdf_log(world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_PARSER, NULL, "Unknown Raptor object identifier type %d", rstatement->object->type); librdf_free_statement(statement); return; } if(!node) { librdf_log(world, 0, LIBRDF_LOG_FATAL, LIBRDF_FROM_PARSER, NULL, "Cannot create object node"); librdf_free_statement(statement); return; } librdf_statement_set_object(statement, node); #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 if(1) { raptor_iostream *iostr; iostr = raptor_new_iostream_to_file_handle(world->raptor_world_ptr, stderr); librdf_statement_write(statement, iostr); raptor_free_iostream(iostr); } #endif if(scontext->model) { rc=librdf_model_add_statement(scontext->model, statement); librdf_free_statement(statement); } else { rc=librdf_list_add(scontext->statements, statement); if(rc) librdf_free_statement(statement); } if(rc) { librdf_log(world, 0, LIBRDF_LOG_FATAL, LIBRDF_FROM_PARSER, NULL, "Cannot add statement to model"); } }
static int librdf_query_rasqal_query_results_update_statement(void* context) { librdf_query_rasqal_stream_context* scontext=(librdf_query_rasqal_stream_context*)context; librdf_world* world=scontext->query->world; librdf_node* node; raptor_statement *rstatement=rasqal_query_results_get_triple(scontext->qcontext->results); if(!rstatement) return 1; scontext->statement=librdf_new_statement(world); if(!scontext->statement) return 1; /* subject */ if(rstatement->subject->type == RAPTOR_TERM_TYPE_BLANK) { node = librdf_new_node_from_blank_identifier(world, rstatement->subject->value.blank.string); } else if(rstatement->subject->type == RAPTOR_TERM_TYPE_URI) { node = librdf_new_node_from_uri_string(world, librdf_uri_as_string((librdf_uri*)rstatement->subject->value.uri)); } else { librdf_log(world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_QUERY, NULL, "Unknown Raptor subject identifier type %d", rstatement->subject->type); goto fail; } if(!node) { librdf_log(world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_QUERY, NULL, "Could not create subject node"); goto fail; } librdf_statement_set_subject(scontext->statement, node); /* predicate */ if(rstatement->predicate->type == RAPTOR_TERM_TYPE_URI) { node = librdf_new_node_from_uri_string(world, librdf_uri_as_string((librdf_uri*)rstatement->predicate->value.uri)); } else { librdf_log(world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_QUERY, NULL, "Unknown Raptor predicate identifier type %d", rstatement->predicate->type); goto fail; } if(!node) { librdf_log(world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_QUERY, NULL, "Could not create predicate node"); goto fail; } librdf_statement_set_predicate(scontext->statement, node); /* object */ if(rstatement->object->type == RAPTOR_TERM_TYPE_LITERAL) { node = librdf_new_node_from_typed_literal(world, rstatement->object->value.literal.string, (const char*)rstatement->object->value.literal.language, (librdf_uri*)rstatement->object->value.literal.datatype); } else if(rstatement->object->type == RAPTOR_TERM_TYPE_BLANK) { node = librdf_new_node_from_blank_identifier(world, rstatement->object->value.blank.string); } else if(rstatement->object->type == RAPTOR_TERM_TYPE_URI) { node = librdf_new_node_from_uri_string(world, librdf_uri_as_string((librdf_uri*)rstatement->object->value.uri)); } else { librdf_log(world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_PARSER, NULL, "Unknown Raptor object identifier type %d", rstatement->object->type); goto fail; } if(!node) { librdf_log(world, 0, LIBRDF_LOG_ERROR, LIBRDF_FROM_QUERY, NULL, "Could not create object node"); goto fail; } librdf_statement_set_object(scontext->statement, node); return 0; /* success */ fail: librdf_free_statement(scontext->statement); scontext->statement=NULL; return 1; }
void reasoning(sib_data_structure* param, ssTriple_t* t, gboolean* enable_real_reasoning) { librdf_statement* statement; //Insert object as class if(strcmp(t->predicate,rdf_ex "type")==0 && strcmp(t->object,rdfs_ex "Class")!=0) { statement=librdf_new_statement(param->RDF_world); librdf_statement_set_subject(statement,librdf_new_node_from_uri_string(param->RDF_world, t->object)); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "type")); librdf_statement_set_object(statement, librdf_new_node_from_uri_string(param->RDF_world, rdfs_ex "Class")); librdf_model_add_statement(param->RDF_model, statement); //FOR SUBSCRIBE statement_in_tl(&(param->RDF_list_insert),statement); //librdf_model_add_statement(param->RDF_model_insert, statement); librdf_free_statement(statement); if (enable_real_reasoning) ////////////////////////////////////////////// { check_subtype_and_add(param, t->subject,t->object); } /////////////////////////////////////////////// } //Insert subject and object as class else if(strcmp(t->predicate,rdfs_ex "subClassOf")==0) { statement=librdf_new_statement(param->RDF_world); librdf_statement_set_subject(statement,librdf_new_node_from_uri_string(param->RDF_world, t->subject)); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "type")); librdf_statement_set_object(statement, librdf_new_node_from_uri_string(param->RDF_world, rdfs_ex "Class")); librdf_model_add_statement(param->RDF_model, statement); //FOR SUBSCRIBE statement_in_tl(&(param->RDF_list_insert),statement); //librdf_model_add_statement(param->RDF_model_insert, statement); librdf_free_statement(statement); statement=librdf_new_statement(param->RDF_world); librdf_statement_set_subject(statement,librdf_new_node_from_uri_string(param->RDF_world, t->object)); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "type")); librdf_statement_set_object(statement, librdf_new_node_from_uri_string(param->RDF_world, rdfs_ex "Class")); librdf_model_add_statement(param->RDF_model, statement); //FOR SUBSCRIBE statement_in_tl(&(param->RDF_list_insert),statement); //librdf_model_add_statement(param->RDF_model_insert, statement); librdf_free_statement(statement); ////////////////////////////////////////////// if (enable_real_reasoning) { add_sub_type(param, t->subject,t->object); } /////////////////////////////////////////////// } //Insert subject and object as property else if(strcmp(t->predicate,rdfs_ex "subPropertyOf")==0) { statement=librdf_new_statement(param->RDF_world); librdf_statement_set_subject(statement,librdf_new_node_from_uri_string(param->RDF_world, t->subject)); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "type")); librdf_statement_set_object(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "Property")); librdf_model_add_statement(param->RDF_model, statement); //FOR SUBSCRIBE statement_in_tl(&(param->RDF_list_insert),statement); //librdf_model_add_statement(param->RDF_model_insert, statement); librdf_free_statement(statement); statement=librdf_new_statement(param->RDF_world); librdf_statement_set_subject(statement,librdf_new_node_from_uri_string(param->RDF_world, t->object)); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "type")); librdf_statement_set_object(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "Property")); librdf_model_add_statement(param->RDF_model, statement); //FOR SUBSCRIBE statement_in_tl(&(param->RDF_list_insert),statement); //librdf_model_add_statement(param->RDF_model_insert, statement); librdf_free_statement(statement); //////////////////////////////// if (enable_real_reasoning) { add_sub_properties(param, t->subject, t->object); } //////////////////////////////// } //Insert subject and object as property and class(domain and range) else if(strcmp(t->predicate,rdfs_ex "domain")==0 ) { statement=librdf_new_statement(param->RDF_world); librdf_statement_set_subject(statement,librdf_new_node_from_uri_string(param->RDF_world, t->subject)); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "type")); librdf_statement_set_object(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "Property")); librdf_model_add_statement(param->RDF_model, statement); //FOR SUBSCRIBE statement_in_tl(&(param->RDF_list_insert),statement); //librdf_model_add_statement(param->RDF_model_insert, statement); librdf_free_statement(statement); statement=librdf_new_statement(param->RDF_world); librdf_statement_set_subject(statement,librdf_new_node_from_uri_string(param->RDF_world, t->object)); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "type")); librdf_statement_set_object(statement, librdf_new_node_from_uri_string(param->RDF_world, rdfs_ex "Class")); librdf_model_add_statement(param->RDF_model, statement); //FOR SUBSCRIBE statement_in_tl(&(param->RDF_list_insert),statement); //librdf_model_add_statement(param->RDF_model_insert, statement); librdf_free_statement(statement); ////////////////////////////////////////////////////////////////////////////////////// if (enable_real_reasoning) { add_properties_domain(param, t->subject, t->object); } ////////////////////////////////////////////////////////////////////////////////////// } else if(strcmp(t->predicate,rdfs_ex "range")==0) { statement=librdf_new_statement(param->RDF_world); librdf_statement_set_subject(statement,librdf_new_node_from_uri_string(param->RDF_world, t->subject)); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "type")); librdf_statement_set_object(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "Property")); librdf_model_add_statement(param->RDF_model, statement); //FOR SUBSCRIBE statement_in_tl(&(param->RDF_list_insert),statement); //librdf_model_add_statement(param->RDF_model_insert, statement); librdf_free_statement(statement); statement=librdf_new_statement(param->RDF_world); librdf_statement_set_subject(statement,librdf_new_node_from_uri_string(param->RDF_world, t->object)); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "type")); librdf_statement_set_object(statement, librdf_new_node_from_uri_string(param->RDF_world, rdfs_ex "Class")); librdf_model_add_statement(param->RDF_model, statement); //FOR SUBSCRIBE statement_in_tl(&(param->RDF_list_insert),statement); //librdf_model_add_statement(param->RDF_model_insert, statement); librdf_free_statement(statement); ////////////////////////////////////////////////////////////////////////////////////// if (enable_real_reasoning) { add_properties_range(param, t->subject, t->object); } ////////////////////////////////////////////////////////////////////////////////////// } // All other cases! // Insert predicate as property (eventually check for subproperties) else if(strcmp(t->predicate,rdf_ex "type")!=0) { statement=librdf_new_statement(param->RDF_world); librdf_statement_set_subject(statement, librdf_new_node_from_uri_string(param->RDF_world, t->predicate)); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "type")); librdf_statement_set_object(statement, librdf_new_node_from_uri_string(param->RDF_world, rdf_ex "Property")); librdf_model_add_statement(param->RDF_model, statement); //FOR SUBSCRIBE statement_in_tl(&(param->RDF_list_insert),statement); //librdf_model_add_statement(param->RDF_model_insert, statement); librdf_free_statement(statement); ////////////////////////////////////////////// if (enable_real_reasoning) { check_if_predicate_subproperty_and_add(param,t->subject,t->predicate,t->object); check_if_property_in_domain_and_add_subject_type(param, t->subject, t->predicate); check_if_property_in_range_and_add_object_type(param, t->object, t->predicate); } ////////////////////////////////////////////// } }
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); }
/* * librdf_storage_node_stream_to_node_create - Create a stream for get sources, targets or arcs methods using find_statements method * @storage: the storage object to use * @node1: the first node to encode in the key * @node2: the second node to encode in the key * @want: the field required from the statement * * Return value: a new &librdf_iterator or NULL on failure **/ static librdf_iterator* librdf_storage_node_stream_to_node_create(librdf_storage* storage, librdf_node *node1, librdf_node *node2, librdf_statement_part want) { librdf_statement *partial_statement; librdf_stream *stream; librdf_storage_stream_to_node_iterator_context* context; librdf_iterator *iterator; LIBRDF_ASSERT_OBJECT_POINTER_RETURN_VALUE(storage, librdf_storage, NULL); LIBRDF_ASSERT_OBJECT_POINTER_RETURN_VALUE(node1, librdf_node, NULL); LIBRDF_ASSERT_OBJECT_POINTER_RETURN_VALUE(node2, librdf_node, NULL); partial_statement=librdf_new_statement(storage->world); if(!partial_statement) return NULL; context=(librdf_storage_stream_to_node_iterator_context*)LIBRDF_CALLOC(librdf_storage_stream_to_node_iterator_context, 1, sizeof(librdf_storage_stream_to_node_iterator_context)); if(!context) { librdf_free_statement(partial_statement); return NULL; } switch(want) { case LIBRDF_STATEMENT_SUBJECT: librdf_statement_set_predicate(partial_statement, node1); librdf_statement_set_object(partial_statement, node2); break; case LIBRDF_STATEMENT_PREDICATE: librdf_statement_set_subject(partial_statement, node1); librdf_statement_set_object(partial_statement, node2); break; case LIBRDF_STATEMENT_OBJECT: librdf_statement_set_subject(partial_statement, node1); librdf_statement_set_predicate(partial_statement, node2); break; default: librdf_free_statement(partial_statement); LIBRDF_ERROR2(storage->world, "Illegal statement part %d seen\n", want); return NULL; } stream=storage->factory->find_statements(storage, partial_statement); if(!stream) { librdf_storage_stream_to_node_iterator_finished(context); return NULL; } /* initialise context */ context->partial_statement=partial_statement; context->stream=stream; context->want=want; context->storage=storage; librdf_storage_add_reference(context->storage); iterator=librdf_new_iterator(storage->world, (void*)context, librdf_storage_stream_to_node_iterator_is_end, librdf_storage_stream_to_node_iterator_next_method, librdf_storage_stream_to_node_iterator_get_method, librdf_storage_stream_to_node_iterator_finished); if(!iterator) librdf_storage_stream_to_node_iterator_finished(context); return iterator; }