/* * call-seq: * graph.search( subject, predicate, object ) -> array * graph[ subject, predicate, object ] -> array * * Search for statements in the graph with the specified +subject+, +predicate+, and +object+ and * return them. If +subject+, +predicate+, or +object+ are nil, they will match any value. * * # Match any statements about authors * graph.load( 'http://deveiant.livejournal.com/data/foaf' ) * * # * graph[ nil, FOAF[:knows], nil ] # => [...] */ static VALUE rleaf_redleaf_graph_search( VALUE self, VALUE subject, VALUE predicate, VALUE object ) { rleaf_GRAPH *ptr = rleaf_get_graph( self ); librdf_node *subject_node, *predicate_node, *object_node; librdf_statement *search_statement, *stmt; librdf_stream *stream; int count = 0; VALUE rval = rb_ary_new(); rleaf_log_with_context( self, "debug", "searching for statements matching {%s, %s, %s}", RSTRING_PTR(rb_inspect(subject)), RSTRING_PTR(rb_inspect(predicate)), RSTRING_PTR(rb_inspect(object)) ); subject_node = rleaf_value_to_subject_node( subject ); predicate_node = rleaf_value_to_predicate_node( predicate ); object_node = rleaf_value_to_object_node( object ); search_statement = librdf_new_statement_from_nodes( rleaf_rdf_world, subject_node, predicate_node, object_node ); if ( !search_statement ) rb_raise( rleaf_eRedleafError, "could not create a statement from nodes [%s, %s, %s]", RSTRING_PTR(rb_inspect(subject)), RSTRING_PTR(rb_inspect(predicate)), RSTRING_PTR(rb_inspect(object)) ); stream = librdf_model_find_statements( ptr->model, search_statement ); if ( !stream ) { librdf_free_statement( search_statement ); rb_raise( rleaf_eRedleafError, "could not create a stream when searching" ); } while ( ! librdf_stream_end(stream) ) { stmt = librdf_stream_get_object( stream ); if ( !stmt ) break; count++; rb_ary_push( rval, rleaf_librdf_statement_to_value(stmt) ); librdf_stream_next( stream ); } rleaf_log_with_context( self, "debug", "found %d statements", count ); librdf_free_stream( stream ); librdf_free_statement( search_statement ); return rval; }
/* * call-seq: * graph.remove( statement ) -> array * * Removes one or more statements from the graph that match the specified +statement+ * (either a Redleaf::Statement or a valid triple in an Array) and returns any that * were removed. * * Any +nil+ values in the statement will match any value. * * # Set a new home page for the Redleaf project, preserving the old one * # as the 'old_homepage' * stmt = graph.remove([ :Redleaf, DOAP[:homepage], nil ]) * stmt.predicate = DOAP[:old_homepage] * graph.append( stmt ) * graph.append([ :Redleaf, DOAP[:homepage], * URL.parse('http://deveiate.org/projects/Redleaf') ]) */ static VALUE rleaf_redleaf_graph_remove( VALUE self, VALUE statement ) { rleaf_GRAPH *ptr = rleaf_get_graph( self ); librdf_statement *search_statement, *stmt; librdf_stream *stream; int count = 0; VALUE rval = rb_ary_new(); rleaf_log_with_context( self, "debug", "removing statements matching %s", RSTRING_PTR(rb_inspect(statement)) ); search_statement = rleaf_value_to_librdf_statement( statement ); stream = librdf_model_find_statements( ptr->model, search_statement ); if ( !stream ) { librdf_free_statement( search_statement ); rb_raise( rleaf_eRedleafError, "could not create a stream when removing %s from %s", RSTRING_PTR(rb_inspect(statement)), RSTRING_PTR(rb_inspect(self)) ); } while ( ! librdf_stream_end(stream) ) { if ( (stmt = librdf_stream_get_object( stream )) == NULL ) break; count++; rb_ary_push( rval, rleaf_librdf_statement_to_value(stmt) ); if ( librdf_model_remove_statement(ptr->model, stmt) != 0 ) { librdf_free_stream( stream ); librdf_free_statement( search_statement ); rb_raise( rleaf_eRedleafError, "failed to remove statement from model" ); } librdf_stream_next( stream ); } rleaf_log_with_context( self, "debug", "removed %d statements", count ); librdf_free_stream( stream ); librdf_free_statement( search_statement ); return rval; }
/* * call-seq: * graph.include?( statement ) -> true or false * graph.contains?( statement ) -> true or false * * Return +true+ if the receiver contains the specified +statement+, which can be either a * Redleaf::Statement object or a valid triple in an Array. * */ static VALUE rleaf_redleaf_graph_include_p( VALUE self, VALUE statement ) { rleaf_GRAPH *ptr = rleaf_get_graph( self ); librdf_statement *stmt; librdf_stream *stream; VALUE rval = Qfalse; rleaf_log_with_context( self, "debug", "checking for statement matching %s", RSTRING_PTR(rb_inspect(statement)) ); stmt = rleaf_value_to_librdf_statement( statement ); /* According to the Redland docs, this is a better way to test this than librdf_model_contains_statement if the model has contexts. Since we want to support contexts, it's easier just to assume that they're always enabled. */ stream = librdf_model_find_statements( ptr->model, stmt ); if ( stream != NULL && !librdf_stream_end(stream) ) rval = Qtrue; librdf_free_stream( stream ); librdf_free_statement( stmt ); return rval; }
static int rasqal_redland_init_triples_match(rasqal_triples_match* rtm, rasqal_triples_source *rts, void *user_data, rasqal_triple_meta *m, rasqal_triple *t) { rasqal_redland_triples_source_user_data* rtsc=(rasqal_redland_triples_source_user_data*)user_data; rasqal_redland_triples_match_context* rtmc; rasqal_variable* var; rtm->bind_match=rasqal_redland_bind_match; rtm->next_match=rasqal_redland_next_match; rtm->is_end=rasqal_redland_is_end; rtm->finish=rasqal_redland_finish_triples_match; rtmc = LIBRDF_CALLOC(rasqal_redland_triples_match_context*, 1, sizeof(*rtmc)); if(!rtmc) return 1; rtm->user_data=rtmc; /* at least one of the triple terms is a variable and we need to * do a triplesMatching() aka librdf_model_find_statements * * redland find_statements will do the right thing and internally * pick the most efficient, indexed way to get the answer. */ if((var=rasqal_literal_as_variable(t->subject))) { if(var->value) rtmc->nodes[0]=rasqal_literal_to_redland_node(rtsc->world, var->value); else rtmc->nodes[0]=NULL; } else rtmc->nodes[0]=rasqal_literal_to_redland_node(rtsc->world, t->subject); m->bindings[0]=var; if((var=rasqal_literal_as_variable(t->predicate))) { if(var->value) rtmc->nodes[1]=rasqal_literal_to_redland_node(rtsc->world, var->value); else rtmc->nodes[1]=NULL; } else rtmc->nodes[1]=rasqal_literal_to_redland_node(rtsc->world, t->predicate); m->bindings[1]=var; if((var=rasqal_literal_as_variable(t->object))) { if(var->value) rtmc->nodes[2]=rasqal_literal_to_redland_node(rtsc->world, var->value); else rtmc->nodes[2]=NULL; } else rtmc->nodes[2]=rasqal_literal_to_redland_node(rtsc->world, t->object); m->bindings[2]=var; if(t->origin) { if((var=rasqal_literal_as_variable(t->origin))) { if(var->value) rtmc->origin=rasqal_literal_to_redland_node(rtsc->world, var->value); } else rtmc->origin=rasqal_literal_to_redland_node(rtsc->world, t->origin); m->bindings[3]=var; } rtmc->qstatement=librdf_new_statement_from_nodes(rtsc->world, rtmc->nodes[0], rtmc->nodes[1], rtmc->nodes[2]); if(!rtmc->qstatement) return 1; #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("query statement: "); librdf_statement_print(rtmc->qstatement, stderr); if(rtmc->origin) { fput(" with context node: ", stderr); librdf_node_print(rtmc->origin, stderr); } fputc('\n', stderr); #endif if(rtmc->origin) rtmc->stream=librdf_model_find_statements_in_context(rtsc->model, rtmc->qstatement, rtmc->origin); else rtmc->stream=librdf_model_find_statements(rtsc->model, rtmc->qstatement); if(!rtmc->stream) return 1; #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("rasqal_init_triples_match done\n"); #endif return 0; }
UT_Error IE_Imp_OpenDocument::_handleRDFStreams () { #ifndef WITH_REDLAND return UT_OK; #else UT_Error error = UT_OK; UT_DEBUGMSG(("IE_Imp_OpenDocument::_handleRDFStreams()\n")); // // DEBUG. // { // PD_DocumentRDFHandle rdf = getDoc()->getDocumentRDF(); // PD_DocumentRDFMutationHandle m = rdf->createMutation(); // m->add( PD_URI("http://www.example.com/foo#bar" ), // PD_URI("http://www.example.com/foo#bar" ), // PD_Object("http://www.example.com/foo#bar" ) ); // m->commit(); // rdf->dumpModel("added foo"); // } RDFArguments args; librdf_model* model = args.model; // check if we can load a manifest.rdf file GsfInput* pRdfManifest = gsf_infile_child_by_name(m_pGsfInfile, "manifest.rdf"); if (pRdfManifest) { UT_DEBUGMSG(("IE_Imp_OpenDocument::_handleRDFStreams() have manifest.rdf\n")); error = _loadRDFFromFile( pRdfManifest, "manifest.rdf", &args ); g_object_unref (G_OBJECT (pRdfManifest)); if (error != UT_OK) return error; } // find other RDF/XML files referenced in the manifest const char* query_string = "" "prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> \n" "prefix odf: <http://docs.oasis-open.org/opendocument/meta/package/odf#> \n" "prefix odfcommon: <http://docs.oasis-open.org/opendocument/meta/package/common#> \n" "select ?subj ?fileName \n" " where { \n" " ?subj rdf:type odf:MetaDataFile . \n" " ?subj odfcommon:path ?fileName \n" " } \n"; librdf_uri* base_uri = 0; librdf_query* query = librdf_new_query( args.world, "sparql", 0, (unsigned char*)query_string, base_uri ); librdf_query_results* results = librdf_query_execute( query, model ); if( !results ) { // Query failed is a failure to execute the SPARQL, // in which case there might be results but we couldn't find them UT_DEBUGMSG(("IE_Imp_OpenDocument::_handleRDFStreams() SPARQL query to find auxillary RDF/XML files failed! q:%p\n", query )); error = UT_ERROR; } else { UT_DEBUGMSG(("IE_Imp_OpenDocument::_handleRDFStreams() aux RDF/XML file count:%d\n", librdf_query_results_get_count( results ))); // parse auxillary RDF/XML files too for( ; !librdf_query_results_finished( results ) ; librdf_query_results_next( results )) { librdf_node* fnNode = librdf_query_results_get_binding_value_by_name ( results, "fileName" ); UT_DEBUGMSG(("_handleRDFStreams() fnNode:%p\n", fnNode )); std::string fn = toString(fnNode); UT_DEBUGMSG(("_handleRDFStreams() loading auxilary RDF/XML file from:%s\n", fn.c_str())); GsfInput* pAuxRDF = gsf_infile_child_by_name(m_pGsfInfile, fn.c_str()); if (pAuxRDF) { error = _loadRDFFromFile( pAuxRDF, fn.c_str(), &args ); g_object_unref (G_OBJECT (pAuxRDF)); if( error != UT_OK ) break; } else { UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN); return UT_ERROR; } } librdf_free_query_results( results ); } librdf_free_query( query ); UT_DEBUGMSG(("_handleRDFStreams() error:%d model.sz:%d\n", error, librdf_model_size( model ))); if( error != UT_OK ) { return error; } // convert the redland model into native AbiWord RDF triples { PD_DocumentRDFHandle rdf = getDoc()->getDocumentRDF(); PD_DocumentRDFMutationHandle m = rdf->createMutation(); librdf_statement* statement = librdf_new_statement( args.world ); librdf_stream* stream = librdf_model_find_statements( model, statement ); while (!librdf_stream_end(stream)) { librdf_statement* current = librdf_stream_get_object( stream ); int objectType = PD_Object::OBJECT_TYPE_URI; std::string xsdType = ""; if( librdf_node_is_blank( librdf_statement_get_object( current ))) { objectType = PD_Object::OBJECT_TYPE_BNODE; } if( librdf_node_is_literal( librdf_statement_get_object( current ))) { objectType = PD_Object::OBJECT_TYPE_LITERAL; if( librdf_uri* u = librdf_node_get_literal_value_datatype_uri( librdf_statement_get_object( current ))) { xsdType = toString(u); } } if( DEBUG_RDF_IO ) { UT_DEBUGMSG(("_handleRDFStreams() adding s:%s p:%s o:%s rotv:%d otv:%d ots:%s\n", toString( librdf_statement_get_subject( current )).c_str(), toString( librdf_statement_get_predicate( current )).c_str(), toString( librdf_statement_get_object( current )).c_str(), librdf_node_get_type(librdf_statement_get_object( current )), objectType, xsdType.c_str() )); } m->add( PD_URI( toString( librdf_statement_get_subject( current ))), PD_URI( toString( librdf_statement_get_predicate( current ))), PD_Object( toString( librdf_statement_get_object( current )), objectType, xsdType )); // m->add( PD_URI( toString( librdf_statement_get_subject( current ))), // PD_URI( toString( librdf_statement_get_predicate( current ))), // PD_Object( toString( librdf_statement_get_object( current )), // objectType, // xsdType )); librdf_stream_next(stream); } librdf_free_stream( stream ); librdf_free_statement( statement ); // m->add( PD_URI("http://www.example.com/foo#bar" ), // PD_URI("http://www.example.com/foo#bar" ), // PD_Object("http://www.example.com/foo#bar" ) ); m->commit(); } if( DEBUG_RDF_IO ) { getDoc()->getDocumentRDF()->dumpModel("Loaded RDF from ODF file"); } return error; #endif }
static librdf_stream* librdf_storage_file_find_statements(librdf_storage* storage, librdf_statement* statement) { librdf_storage_file_instance* context=(librdf_storage_file_instance*)storage->instance; return librdf_model_find_statements(context->model, statement); }