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