/**
* librdf_new_statement_from_nodes:
* @world: redland world object
* @subject: #librdf_node
* @predicate: #librdf_node
* @object: #librdf_node
*
* Constructor - create a new #librdf_statement from existing #librdf_node objects.
*
* The node objects become owned by the new statement (or freed on error).
*
* Return value: a new #librdf_statement with copy or NULL on failure
**/
librdf_statement*
librdf_new_statement_from_nodes(librdf_world *world,
librdf_node* subject,
librdf_node* predicate,
librdf_node* object)
{
librdf_statement* new_statement;
librdf_world_open(world);
new_statement = librdf_new_statement(world);
if(!new_statement) {
if(subject)
librdf_free_node(subject);
if(predicate)
librdf_free_node(predicate);
if(object)
librdf_free_node(object);
return NULL;
}
new_statement->subject=subject;
new_statement->predicate=predicate;
new_statement->object=object;
return new_statement;
}
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;
}
RdfStatement::RdfStatement(IWorld* world) : IStatement(world)
{
RdfWorld* rdfWorld = dynamic_cast<RdfWorld*>(world);
assert(rdfWorld && "Failed to dynamic cast IWorld to RdfWorld");
if (rdfWorld)
statement = librdf_new_statement(rdfWorld->world);
else
LogError("Failed to cast IWorld to RdfWorld.");
}
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);
}
/**
* librdf_new_statement_from_statement:
* @statement: #librdf_statement to copy
*
* Copy constructor - create a new librdf_statement from an existing librdf_statement.
*
* Return value: a new #librdf_statement with copy or NULL on failure
**/
librdf_statement*
librdf_new_statement_from_statement(librdf_statement* statement)
{
librdf_statement* new_statement;
LIBRDF_ASSERT_OBJECT_POINTER_RETURN_VALUE(statement, librdf_statement, NULL);
if(!statement)
return NULL;
new_statement = librdf_new_statement(statement->world);
if(!new_statement)
return NULL;
if(statement->subject) {
new_statement->subject=librdf_new_node_from_node(statement->subject);
if(!new_statement->subject) {
librdf_free_statement(new_statement);
return NULL;
}
}
if(statement->predicate) {
new_statement->predicate=librdf_new_node_from_node(statement->predicate);
if(!new_statement->predicate) {
librdf_free_statement(new_statement);
return NULL;
}
}
if(statement->object) {
new_statement->object=librdf_new_node_from_node(statement->object);
if(!new_statement->object) {
librdf_free_statement(new_statement);
return NULL;
}
}
return new_statement;
}
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;
}
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
}
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;
}