/**
* librdf_stream_print:
* @stream: the stream object
* @fh: the FILE stream to print to
*
* Print the stream.
*
* This prints the remaining statements of the stream to the given
* file handle. Note that after this method is called the stream
* will be empty so that librdf_stream_end() will always be true
* and librdf_stream_next() will always return NULL. The only
* useful operation is to dispose of the stream with the
* librdf_free_stream() destructor.
*
* This method is for debugging and the format of the output should
* not be relied on.
*
* @Deprecated: Use librdf_stream_write() to write to
* #raptor_iostream which can be made to write to a string. Use a
* #librdf_serializer to write proper syntax formats.
*
**/
void
librdf_stream_print(librdf_stream *stream, FILE *fh)
{
raptor_iostream *iostr;
if(!stream)
return;
iostr = raptor_new_iostream_to_file_handle(stream->world->raptor_world_ptr, fh);
if(!iostr)
return;
while(!librdf_stream_end(stream)) {
librdf_statement* statement = librdf_stream_get_object(stream);
librdf_node* context_node = librdf_stream_get_context2(stream);
if(!statement)
break;
fputs(" ", fh);
librdf_statement_write(statement, iostr);
if(context_node) {
fputs(" with context ", fh);
librdf_node_print(context_node, fh);
}
fputs("\n", fh);
librdf_stream_next(stream);
}
raptor_free_iostream(iostr);
}
static
void roqet_print_query(rasqal_query* rq,
raptor_world* raptor_world_ptr,
query_output_format output_format,
raptor_uri* base_uri)
{
fprintf(stderr, "Query:\n");
switch(output_format) {
case QUERY_OUTPUT_DEBUG:
rasqal_query_print(rq, stdout);
break;
case QUERY_OUTPUT_STRUCTURE:
roqet_query_walk(rq, stdout, 0);
break;
case QUERY_OUTPUT_SPARQL:
if(1) {
raptor_iostream* output_iostr;
output_iostr = raptor_new_iostream_to_file_handle(raptor_world_ptr,
stdout);
rasqal_query_write(output_iostr, rq, NULL, base_uri);
raptor_free_iostream(output_iostr);
}
break;
case QUERY_OUTPUT_UNKNOWN:
default:
fprintf(stderr, "%s: Unknown query output format %d\n", program,
output_format);
abort();
}
}
/**
* rasqal_rowsource_print:
* @rs: the #rasqal_rowsource object
* @fh: the FILE* handle to print to
*
* Print a #rasqal_rowsource in a debug format.
*
* The print debug format may change in any release.
*
**/
void
rasqal_rowsource_print(rasqal_rowsource *rowsource, FILE* fh)
{
raptor_iostream *iostr;
iostr = raptor_new_iostream_to_file_handle(rowsource->world->raptor_world_ptr, fh);
rasqal_rowsource_write(rowsource, iostr);
raptor_free_iostream(iostr);
}
/**
* librdf_statement_print:
* @statement: the statement
* @fh: file handle
*
* Pretty print the statement to a file descriptor.
*
* This method is for debugging and the format of the output should
* not be relied on.
*
**/
void
librdf_statement_print(librdf_statement *statement, FILE *fh)
{
raptor_iostream *iostr;
LIBRDF_ASSERT_OBJECT_POINTER_RETURN(statement, librdf_statement);
if(!statement)
return;
iostr = raptor_new_iostream_to_file_handle(statement->world->raptor_world_ptr, fh);
if(!iostr)
return;
librdf_statement_write(statement, iostr);
raptor_free_iostream(iostr);
}
int
raptor_term_print_as_ntriples(const raptor_term *term, FILE* stream)
{
int rc = 0;
raptor_iostream* iostr;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(term, raptor_term, 1);
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(stream, FILE*, 1);
iostr = raptor_new_iostream_to_file_handle(term->world, stream);
if(!iostr)
return 1;
rc = raptor_term_ntriples_write(term, iostr);
raptor_free_iostream(iostr);
return rc;
}
static int
print_formatted_query_results(rasqal_world* world,
rasqal_query_results* results,
raptor_world* raptor_world_ptr,
FILE* output,
const char* result_format,
raptor_uri* base_uri,
int quiet)
{
raptor_iostream *iostr;
rasqal_query_results_formatter* results_formatter;
int rc = 0;
results_formatter = rasqal_new_query_results_formatter(world,
result_format,
NULL, NULL);
if(!results_formatter) {
fprintf(stderr, "%s: Invalid bindings result format `%s'\n",
program, result_format);
rc = 1;
goto tidy;
}
iostr = raptor_new_iostream_to_file_handle(raptor_world_ptr, output);
if(!iostr) {
rasqal_free_query_results_formatter(results_formatter);
rc = 1;
goto tidy;
}
rc = rasqal_query_results_formatter_write(iostr, results_formatter,
results, base_uri);
raptor_free_iostream(iostr);
rasqal_free_query_results_formatter(results_formatter);
tidy:
if(rc)
fprintf(stderr, "%s: Formatting query results failed\n", program);
return rc;
}
int
main(int argc, char *argv[])
{
librdf_world* world;
librdf_storage *storage;
librdf_model* model;
librdf_statement* statement;
raptor_world *raptor_world_ptr;
raptor_iostream* iostr;
world=librdf_new_world();
librdf_world_open(world);
raptor_world_ptr = librdf_world_get_raptor(world);
model=librdf_new_model(world, storage=librdf_new_storage(world, "hashes", "test", "hash-type='bdb',dir='.'"), NULL);
librdf_model_add_statement(model,
statement=librdf_new_statement_from_nodes(world, librdf_new_node_from_uri_string(world, (const unsigned char*)"http://www.dajobe.org/"),
librdf_new_node_from_uri_string(world, (const unsigned char*)"http://purl.org/dc/elements/1.1/creator"),
librdf_new_node_from_literal(world, (const unsigned char*)"Dave Beckett", NULL, 0)
)
);
librdf_free_statement(statement);
iostr = raptor_new_iostream_to_file_handle(raptor_world_ptr, stdout);
librdf_model_write(model, iostr);
raptor_free_iostream(iostr);
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);
}
static int
test_write_to_file_handle(raptor_world *world, FILE* handle,
const char* test_string, size_t test_string_len,
const unsigned int expected_bytes_count)
{
raptor_iostream *iostr = NULL;
unsigned long count;
int rc = 0;
const char* const label="write iostream to file handle";
#if defined(RAPTOR_DEBUG) && RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Testing %s\n", program, label);
#endif
iostr = raptor_new_iostream_to_file_handle(world, handle);
if(!iostr) {
fprintf(stderr, "%s: Failed to create %s\n", program, label);
rc = 1;
goto tidy;
}
raptor_iostream_write_bytes(test_string, 1, test_string_len, iostr);
raptor_iostream_write_byte('\n', iostr);
count = raptor_iostream_tell(iostr);
if(count != expected_bytes_count) {
fprintf(stderr, "%s: %s wrote %d bytes, expected %d\n", program, label,
(int)count, expected_bytes_count);
rc = 1;
}
tidy:
if(iostr)
raptor_free_iostream(iostr);
if(rc)
fprintf(stderr, "%s: FAILED Testing %s\n", program, label);
return rc;
}
bool RdfNode::dummy()
{
librdf_world* world;
librdf_storage *storage;
librdf_model* model;
librdf_statement* statement;
raptor_world *raptor_world_ptr;
raptor_iostream* iostr;
world=librdf_new_world();
librdf_world_open(world);
raptor_world_ptr = librdf_world_get_raptor(world);
model=librdf_new_model(world, storage=librdf_new_storage(world, "hashes", nullptr, "hash-type='memory'"), nullptr);
librdf_model_add_statement(model,
statement=librdf_new_statement_from_nodes(world, librdf_new_node_from_uri_string(world, (const unsigned char*)"http://www.dajobe.org/"),
librdf_new_node_from_uri_string(world, (const unsigned char*)"http://purl.org/dc/elements/1.1/creator"),
librdf_new_node_from_literal(world, (const unsigned char*)"Dave Beckett", nullptr, 0)
)
);
librdf_free_statement(statement);
iostr = raptor_new_iostream_to_file_handle(raptor_world_ptr, stdout);
librdf_model_write(model, iostr);
raptor_free_iostream(iostr);
librdf_free_model(model);
librdf_free_storage(storage);
librdf_free_world(world);
#ifdef LIBRDF_MEMORY_DEBUG
librdf_memory_report(stderr);
#endif
return true;
}
/**
* librdf_query_results_to_file_handle2:
* @query_results: #librdf_query_results object
* @handle: file handle to write to
* @name: result format name (or NULL)
* @mime_type: result mime type (or NULL)
* @format_uri: URI of syntax to format to (or NULL)
* @base_uri: Base URI of output formatted syntax
*
* Write a query results to a FILE*.
*
* A query results format can be named, have a mime type, or
* identified by a URI, all of which are optional. The default
* query results format will be used if @name, @mime_type and @format_uri
* are all NULL.
*
* librdf_query_results_formats_enumerate() returns information on
* the known query results names, labels and URIs.
*
* The @base_uri may be used for as the base URI the generated syntax, depending
* on the format.
*
* Return value: non 0 on failure
**/
int
librdf_query_results_to_file_handle2(librdf_query_results *query_results,
FILE *handle,
const char *name,
const char *mime_type,
librdf_uri *format_uri,
librdf_uri *base_uri)
{
raptor_iostream *iostr;
librdf_query_results_formatter *formatter;
int status;
LIBRDF_ASSERT_OBJECT_POINTER_RETURN_VALUE(query_results, query_results, 1);
LIBRDF_ASSERT_OBJECT_POINTER_RETURN_VALUE(handle, FILE*, 1);
iostr = raptor_new_iostream_to_file_handle(query_results->query->world->raptor_world_ptr,
handle);
if(!iostr)
return 1;
formatter = librdf_new_query_results_formatter2(query_results,
name, mime_type,
format_uri);
if(!formatter) {
raptor_free_iostream(iostr);
return 1;
}
status = librdf_query_results_formatter_write(iostr, formatter,
query_results, base_uri);
librdf_free_query_results_formatter(formatter);
raptor_free_iostream(iostr);
return status;
}
/**
* raptor_serializer_start_to_file_handle:
* @rdf_serializer: the #raptor_serializer
* @uri: base URI or NULL if no base URI is required
* @fh: FILE* to serialize to
*
* Start serializing to a FILE*.
*
* NOTE: This does not fclose the handle when it is finished.
*
* Return value: non-0 on failure.
**/
int
raptor_serializer_start_to_file_handle(raptor_serializer *rdf_serializer,
raptor_uri *uri, FILE *fh)
{
if(rdf_serializer->base_uri)
raptor_free_uri(rdf_serializer->base_uri);
if(uri)
rdf_serializer->base_uri = raptor_uri_copy(uri);
else
rdf_serializer->base_uri = NULL;
rdf_serializer->locator.uri = rdf_serializer->base_uri;
rdf_serializer->locator.line = rdf_serializer->locator.column = 0;
rdf_serializer->iostream = raptor_new_iostream_to_file_handle(rdf_serializer->world, fh);
if(!rdf_serializer->iostream)
return 1;
rdf_serializer->free_iostream_on_end = 1;
if(rdf_serializer->factory->serialize_start)
return rdf_serializer->factory->serialize_start(rdf_serializer);
return 0;
}
int
main(int argc, char *argv[])
{
int rc = 1;
int i;
int parsers_count = 0;
int serializers_count = 0;
int mime_types_count = 0;
raptor_syntax_description** parsers = NULL;
raptor_syntax_description** serializers = NULL;
raptor_iostream* iostr = NULL;
type_syntax* type_syntaxes = NULL;
int type_syntaxes_count = 0;
if(argc != 1) {
fprintf(stderr, "%s: USAGE: %s\n", program, program);
return 1;
}
world = raptor_new_world();
if(!world)
goto tidy;
for(i = 0; 1; i++) {
raptor_syntax_description* sd;
sd = (raptor_syntax_description*)raptor_world_get_parser_description(world, i);
if(!sd)
break;
parsers_count++;
mime_types_count += sd->mime_types_count;
}
for(i = 0; 1; i++) {
raptor_syntax_description* sd;
sd = (raptor_syntax_description*)raptor_world_get_serializer_description(world, i);
if(!sd)
break;
serializers_count++;
mime_types_count += sd->mime_types_count;
}
parsers = (raptor_syntax_description**)calloc(parsers_count,
sizeof(raptor_syntax_description*));
if(!parsers)
goto tidy;
serializers = (raptor_syntax_description**)calloc(serializers_count,
sizeof(raptor_syntax_description*));
if(!serializers)
goto tidy;
type_syntaxes = (type_syntax*)calloc(mime_types_count,
sizeof(type_syntax));
if(!type_syntaxes)
goto tidy;
type_syntaxes_count = 0;
for(i = 0; 1; i++) {
raptor_syntax_description* sd;
unsigned int m;
sd = (raptor_syntax_description*)raptor_world_get_parser_description(world, i);
if(!sd)
break;
parsers[i] = sd;
for(m = 0; m < sd->mime_types_count; m++) {
type_syntaxes[type_syntaxes_count].mime_type = sd->mime_types[m].mime_type;
type_syntaxes[type_syntaxes_count].q = sd->mime_types[m].q;
type_syntaxes[type_syntaxes_count].parser_sd = sd;
type_syntaxes_count++;
}
}
qsort(parsers, parsers_count, sizeof(raptor_syntax_description*),
sort_sd_by_name);
for(i = 0; 1; i++) {
raptor_syntax_description* sd;
unsigned int m;
sd = (raptor_syntax_description*)raptor_world_get_serializer_description(world, i);
if(!sd)
break;
serializers[i] = sd;
for(m = 0; m < sd->mime_types_count; m++) {
type_syntaxes[type_syntaxes_count].mime_type = sd->mime_types[m].mime_type;
type_syntaxes[type_syntaxes_count].q = sd->mime_types[m].q;
type_syntaxes[type_syntaxes_count].serializer_sd = sd;
type_syntaxes_count++;
}
}
qsort(serializers, serializers_count, sizeof(raptor_syntax_description*),
sort_sd_by_name);
iostr = raptor_new_iostream_to_file_handle(world, stdout);
if(!iostr)
goto tidy;
/* MIME Types by parser */
emit_header("raptor-formats", iostr);
emit_start_section("raptor-formats-intro",
"Introduction",
iostr);
raptor_iostream_string_write(
"<para>\n"
"The parsers and serializers in raptor can handle different MIME Types with different levels of quality (Q). A Q of 1.0 indicates that the parser or serializer will be able to read or write the full format with high quality, and it should be the prefered parser or serializer for that mime type. Lower Q values indicate either additional mime type support (for parsing) or less-preferred mime types (for serializing). A serializer typically has just 1 mime type of Q 1.0; the preferred type."
"</para>\n"
,
iostr);
emit_end_section(iostr);
emit_start_section("raptor-formats-types-by-parser",
"MIME Types by Parser",
iostr);
emit_start_desc_list(NULL, iostr);
for(i = 0; i < parsers_count; i++) {
emit_format_description(NULL, parsers[i],
iostr);
}
emit_end_desc_list(iostr);
emit_end_section(iostr);
/* MIME Types by serializer */
emit_start_section("raptor-formats-types-by-serializer",
"MIME Types by Serializer",
iostr);
emit_start_desc_list(NULL, iostr);
for(i = 0; i < serializers_count; i++) {
emit_format_description(NULL, serializers[i],
iostr);
}
emit_end_desc_list(iostr);
emit_end_section(iostr);
/* MIME Types index */
qsort(type_syntaxes, type_syntaxes_count, sizeof(type_syntax),
sort_type_syntax_by_mime_type);
emit_start_section("raptor-formats-types-index",
"MIME Types Index",
iostr);
emit_start_desc_list(NULL, iostr);
if(1) {
const char* last_mime_type = NULL;
int last_start_index = -1;
for(i = 0; i < type_syntaxes_count; i++) {
const char *this_mime_type = type_syntaxes[i].mime_type;
if(last_start_index < 0) {
last_mime_type = this_mime_type;
last_start_index = i;
continue;
}
/* continue if same mime type */
if(!strcmp(last_mime_type, this_mime_type))
continue;
emit_format_to_syntax_list(iostr, type_syntaxes,
last_mime_type, last_start_index, i-1);
last_mime_type = type_syntaxes[i].mime_type;
last_start_index = i;
}
emit_format_to_syntax_list(iostr, type_syntaxes,
last_mime_type, last_start_index, i-1);
}
emit_end_desc_list(iostr);
emit_end_section(iostr);
emit_footer(iostr);
raptor_free_iostream(iostr);
iostr = NULL;
/* success */
rc = 0;
tidy:
if(iostr)
raptor_free_iostream(iostr);
if(parsers)
free(parsers);
if(serializers)
free(serializers);
if(type_syntaxes)
free(type_syntaxes);
if(world)
raptor_free_world(world);
return rc;
}
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");
}
}
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);
}
