/*
* raptor_new_qname_from_resource:
* @namespaces: sequence of namespaces (corresponding to nstack)
* @nstack: #raptor_namespace_stack to use/update
* @namespace_count: size of nstack (may be modified)
* @node: #raptor_abbrev_node to use
*
* Make an XML QName from the URI associated with the node.
*
* Return value: the QName or NULL on failure
**/
raptor_qname*
raptor_new_qname_from_resource(raptor_sequence* namespaces,
raptor_namespace_stack* nstack,
int* namespace_count,
raptor_abbrev_node* node)
{
unsigned char* name=NULL; /* where to split predicate name */
size_t name_len=1;
unsigned char *uri_string;
size_t uri_len;
unsigned char c;
unsigned char *p;
raptor_uri *ns_uri;
raptor_namespace *ns;
raptor_qname *qname;
if(node->type != RAPTOR_IDENTIFIER_TYPE_RESOURCE) {
RAPTOR_FATAL1("Node must be a resource\n");
return NULL;
}
qname=raptor_namespaces_qname_from_uri(nstack,
node->value.resource.uri, 10);
if(qname)
return qname;
uri_string = raptor_uri_as_counted_string(node->value.resource.uri, &uri_len);
p= uri_string;
name_len=uri_len;
while(name_len >0) {
if(raptor_xml_name_check(p, name_len, 10)) {
name=p;
break;
}
p++; name_len--;
}
if(!name || (name == uri_string))
return NULL;
c=*name; *name='\0';
ns_uri=raptor_new_uri(uri_string);
if(!ns_uri)
return NULL;
*name=c;
ns = raptor_namespaces_find_namespace_by_uri(nstack, ns_uri);
if(!ns) {
/* The namespace was not declared, so create one */
unsigned char prefix[2 + MAX_ASCII_INT_SIZE + 1];
*namespace_count = *namespace_count + 1;
sprintf((char *)prefix, "ns%d", *namespace_count);
ns = raptor_new_namespace_from_uri(nstack, prefix, ns_uri, 0);
/* We'll most likely need this namespace again. Push it on our
* stack. It will be deleted in
* raptor_rdfxmla_serialize_terminate
*/
if(raptor_sequence_push(namespaces, ns)) {
/* namespaces sequence has no free handler so we have to free the ns ourselves on error */
raptor_free_namespace(ns);
raptor_free_uri(ns_uri);
return NULL;
}
}
qname = raptor_new_qname_from_namespace_local_name(ns, name, NULL);
raptor_free_uri(ns_uri);
return qname;
}
int
main(int argc, char *argv[])
{
rasqal_world *world;
raptor_world* raptor_world_ptr = NULL;
int rc = 0;
int usage = 0;
int help = 0;
const char* query_language = DEFAULT_QUERY_LANGUAGE;
const char* query_filename = NULL;
const char* data_format_name = NULL;
const char* result_filename = NULL;
const char* result_format_name = NULL;
unsigned char* query_string = NULL;
size_t query_len = 0;
unsigned char *query_base_uri_string = NULL;
int free_query_base_uri_string = 0;
raptor_uri* query_base_uri = NULL;
rasqal_query* rq = NULL;
rasqal_query_results* results = NULL;
rasqal_query_results* expected_results = NULL;
raptor_sequence* data_graphs = NULL;
raptor_iostream* result_iostr = NULL;
rasqal_dataset* ds = NULL;
rasqal_query_results_type results_type;
/* Set globals */
if(1) {
char *p;
program = argv[0];
if((p = strrchr(program, '/')))
program = p + 1;
else if((p = strrchr(program, '\\')))
program = p + 1;
argv[0] = program;
}
world = rasqal_new_world();
if(!world || rasqal_world_open(world)) {
fprintf(stderr, "%s: rasqal_world init failed\n", program);
return(1);
}
raptor_world_ptr = rasqal_world_get_raptor(world);
rasqal_world_set_log_handler(world, world, check_query_log_handler);
/* Option parsing */
while (!usage && !help)
{
int c;
#ifdef HAVE_GETOPT_LONG
int option_index = 0;
c = getopt_long (argc, argv, GETOPT_STRING, long_options, &option_index);
#else
c = getopt (argc, argv, GETOPT_STRING);
#endif
if (c == -1)
break;
switch (c) {
case 0:
case '?': /* getopt() - unknown option */
usage = 1;
break;
case 'd':
verbose++;
break;
case 'F':
if(optarg) {
data_format_name = optarg;
}
break;
case 'h':
help = 1;
break;
case 'l':
if(optarg) {
query_language = optarg;
}
break;
case 'q':
if(optarg) {
query_filename = optarg;
}
break;
case 'Q':
if(optarg) {
query_base_uri_string = (unsigned char*)optarg;
}
break;
case 'r':
if(optarg) {
result_filename = optarg;
}
break;
case 'R':
if(optarg) {
result_format_name = optarg;
}
break;
case 'v':
fputs(rasqal_version_string, stdout);
fputc('\n', stdout);
rasqal_free_world(world);
exit(0);
case 'g':
case 'n':
if(optarg) {
rasqal_data_graph *dg = NULL;
rasqal_data_graph_flags type;
type = (c == 'n') ? RASQAL_DATA_GRAPH_NAMED :
RASQAL_DATA_GRAPH_BACKGROUND;
if(!access((const char*)optarg, R_OK)) {
/* file: use URI */
unsigned char* source_uri_string;
raptor_uri* source_uri;
raptor_uri* graph_name = NULL;
source_uri_string = raptor_uri_filename_to_uri_string((const char*)optarg);
source_uri = raptor_new_uri(raptor_world_ptr, source_uri_string);
raptor_free_memory(source_uri_string);
if(type == RASQAL_DATA_GRAPH_NAMED)
graph_name = source_uri;
if(source_uri)
dg = rasqal_new_data_graph_from_uri(world,
source_uri,
graph_name,
type,
NULL, data_format_name,
NULL);
if(source_uri)
raptor_free_uri(source_uri);
} else {
raptor_uri* source_uri;
raptor_uri* graph_name = NULL;
/* URI: use URI */
source_uri = raptor_new_uri(raptor_world_ptr,
(const unsigned char*)optarg);
if(type == RASQAL_DATA_GRAPH_NAMED)
graph_name = source_uri;
if(source_uri)
dg = rasqal_new_data_graph_from_uri(world,
source_uri,
graph_name,
type,
NULL, data_format_name,
NULL);
if(source_uri)
raptor_free_uri(source_uri);
}
if(!dg) {
fprintf(stderr, "%s: Failed to create data graph for `%s'\n",
program, optarg);
return(1);
}
if(!data_graphs) {
data_graphs = raptor_new_sequence((raptor_data_free_handler)rasqal_free_data_graph,
NULL);
if(!data_graphs) {
fprintf(stderr, "%s: Failed to create data graphs sequence\n",
program);
return(1);
}
}
raptor_sequence_push(data_graphs, dg);
}
break;
}
} /* end while option */
if(!help && !usage) {
if(optind != argc) {
fprintf(stderr, "%s: Extra arguments.\n", program);
usage = 1;
} else if(!result_filename) {
usage = 2; /* Title and usage */
} else if(!query_filename) {
usage = 2; /* Title and usage */
}
}
if(usage) {
if(usage > 1) {
fprintf(stderr, title_format_string, rasqal_version_string);
fputs("Rasqal home page: ", stderr);
fputs(rasqal_home_url_string, stderr);
fputc('\n', stderr);
fputs(rasqal_copyright_string, stderr);
fputs("\nLicense: ", stderr);
fputs(rasqal_license_string, stderr);
fputs("\n\n", stderr);
}
fprintf(stderr, "Try `%s " HELP_ARG(h, help) "' for more information.\n",
program);
rasqal_free_world(world);
exit(1);
}
if(help) {
int i;
printf(title_format_string, rasqal_version_string);
puts("Run an RDF query and check it against a known result.");
printf("Usage: %s [OPTIONS] -g DATA -q QUERY-FILE -r RESULT-FILE\n\n", program);
fputs(rasqal_copyright_string, stdout);
fputs("\nLicense: ", stdout);
puts(rasqal_license_string);
fputs("Rasqal home page: ", stdout);
puts(rasqal_home_url_string);
puts("\nNormal operation is to execute the query in the QUERY-FILE and\ncompare to the query results in RESULT-FILE.");
puts("\nMain options:");
puts(HELP_TEXT("g URI", "default-graph URI", "Use URI as the default graph in the dataset"));
puts(HELP_TEXT("l", "language LANGUAGE ", "Set query language name to one of:"));
for(i = 0; 1; i++) {
const raptor_syntax_description* desc;
desc = rasqal_world_get_query_language_description(world, i);
if(!desc)
break;
printf(" %-15s %s", desc->names[0], desc->label);
if(!i)
puts(" (default)");
else
putchar('\n');
}
puts(HELP_TEXT("n URI", "named-graph URI ", "Add named graph URI to dataset"));
puts(HELP_TEXT("q FILE", "query QUERY-FILE", "Execute query in file QUERY-FILE"));
puts(HELP_TEXT("r FILE", "result FILE ", "Compare to result in file RESULTS-FILE"));
puts("\nAdditional options:");
puts(HELP_TEXT("d", "debug ", "Increase debug message level"));
puts(HELP_TEXT("F", "data-format NAME ", "Set the data source format NAME (default: " DEFAULT_DATA_FORMAT_NAME_GRAPH ")"));
puts(HELP_TEXT("h", "help ", "Print this help, then exit"));
puts(HELP_TEXT("Q URI", "query-base-uri URI", "Set the base URI for the query"));
puts(HELP_TEXT("R", "result-format NAME ", "Set the result format NAME (default: " DEFAULT_RESULT_FORMAT_NAME ")"));
puts(" For variable bindings and boolean results:");
for(i = 0; 1; i++) {
const raptor_syntax_description* desc;
desc = rasqal_world_get_query_results_format_description(world, i);
if(!desc)
break;
if(desc->flags & RASQAL_QUERY_RESULTS_FORMAT_FLAG_READER) {
printf(" %-10s %s", desc->names[0], desc->label);
if(!strcmp(desc->names[0], DEFAULT_RESULT_FORMAT_NAME))
puts(" (default)");
else
putchar('\n');
}
}
puts(" For RDF graph results:");
for(i = 0; 1; i++) {
const raptor_syntax_description *desc;
desc = raptor_world_get_parser_description(raptor_world_ptr, i);
if(!desc)
break;
printf(" %-15s%s", desc->names[0], desc->label);
if(!strcmp(desc->names[0], DEFAULT_DATA_FORMAT_NAME_GRAPH))
puts(" (default)");
else
putchar('\n');
}
puts(HELP_TEXT("v", "version ", "Print the Rasqal version"));
puts("\nReport bugs to http://bugs.librdf.org/");
rasqal_free_world(world);
exit(0);
}
/* Compute query base URI from filename or passed in -Q QUERY-BASE-URI */
if(!query_base_uri_string) {
query_base_uri_string = raptor_uri_filename_to_uri_string(query_filename);
free_query_base_uri_string = 1;
}
query_base_uri = raptor_new_uri(raptor_world_ptr, query_base_uri_string);
if(!query_base_uri) {
fprintf(stderr, "%s: Failed to create URI for %s\n",
program, query_base_uri_string);
return(1);
}
/* Read query from file into a string */
query_string = rasqal_cmdline_read_file_string(program, query_filename,
"query file", &query_len);
if(!query_string) {
rc = 1;
goto tidy_setup;
}
/* Report information */
if(verbose) {
fprintf(stderr, "%s: Reading query in language %s from file %s URI %s:\n",
program, query_language, query_filename,
raptor_uri_as_string(query_base_uri));
if(verbose > 1)
fprintf(stderr, "%s\n", (const char*)query_string);
fprintf(stderr, "%s: Reading results from file '%s'\n",
program, result_filename);
}
/* Parse and prepare query */
rq = check_query_init_query(world, query_language, query_string,
query_base_uri, data_graphs);
if(!rq) {
fprintf(stderr, "%s: Parsing query in %s failed\n", program,
query_filename);
goto tidy_query;
}
/* Query prepared OK - we now know the query details such as result type */
/* Read expected results */
if(1) {
results_type = rasqal_query_get_result_type(rq);
fprintf(stderr, "%s: Expecting result type %d\n", program, results_type);
/* Read result file */
result_iostr = raptor_new_iostream_from_filename(raptor_world_ptr,
result_filename);
if(!result_iostr) {
fprintf(stderr, "%s: result file '%s' open failed - %s\n",
program, result_filename, strerror(errno));
rc = 1;
goto tidy_setup;
}
switch(results_type) {
case RASQAL_QUERY_RESULTS_BINDINGS:
/* read results via rasqal query results format */
expected_results = rasqal_cmdline_read_results(world,
raptor_world_ptr,
results_type,
result_iostr,
result_filename,
result_format_name);
raptor_free_iostream(result_iostr); result_iostr = NULL;
if(!expected_results) {
fprintf(stderr, "%s: Failed to create query results\n", program);
rc = 1;
goto tidy_setup;
}
break;
case RASQAL_QUERY_RESULTS_GRAPH:
/* read results via raptor parser */
if(1) {
const char* format_name = NULL;
if(result_format_name) {
if(!raptor_world_is_parser_name(raptor_world_ptr,
result_format_name)) {
fprintf(stderr,
"%s: invalid parser name `%s' for `" HELP_ARG(R, result-format) "'\n\n",
program, result_format_name);
} else
format_name = result_format_name;
}
if(!format_name)
format_name = DEFAULT_RESULT_FORMAT_NAME;
ds = rasqal_new_dataset(world);
if(!ds) {
fprintf(stderr, "%s: Failed to create dataset", program);
rc = 1;
goto tidy_setup;
}
if(rasqal_dataset_load_graph_iostream(ds, format_name,
result_iostr, NULL)) {
fprintf(stderr, "%s: Failed to load graph into dataset", program);
rc = 1;
goto tidy_setup;
}
raptor_free_iostream(result_iostr); result_iostr = NULL;
/* FIXME
*
* The code at this point should do something with triples
* in the dataset; save them for later to compare them to
* the expected triples. that requires a triples compare
* OR a true RDF graph compare.
*
* Deleting the dataset here frees the triples just loaded.
*/
rasqal_free_dataset(ds); ds = NULL;
}
break;
case RASQAL_QUERY_RESULTS_SYNTAX:
case RASQAL_QUERY_RESULTS_BOOLEAN:
case RASQAL_QUERY_RESULTS_UNKNOWN:
/* failure */
fprintf(stderr,
"%s: Reading %s query results format is not supported",
program, rasqal_query_results_type_label(results_type));
rc = 1;
goto tidy_setup;
}
}
/* save results for query execution so we can print and rewind */
rasqal_query_set_store_results(rq, 1);
results = rasqal_query_execute(rq);
if(results) {
switch(results_type) {
case RASQAL_QUERY_RESULTS_BINDINGS:
fprintf(stderr, "%s: Expected bindings results:\n", program);
rasqal_cmdline_print_bindings_results_simple(program, expected_results,
stderr, 1, 0);
fprintf(stderr, "%s: Actual bindings results:\n", program);
rasqal_cmdline_print_bindings_results_simple(program, results,
stderr, 1, 0);
rasqal_query_results_rewind(expected_results);
rasqal_query_results_rewind(results);
/* FIXME: should NOT do this if results are expected to be ordered */
rasqal_query_results_sort(expected_results, rasqal_row_compare);
rasqal_query_results_sort(results, rasqal_row_compare);
if(1) {
compare_query_results* cqr;
cqr = new_compare_query_results(world,
expected_results, "expected",
results, "actual");
compare_query_results_set_log_handler(cqr, world,
check_query_log_handler);
rc = !compare_query_results_compare(cqr);
free_compare_query_results(cqr); cqr = NULL;
}
break;
case RASQAL_QUERY_RESULTS_BOOLEAN:
case RASQAL_QUERY_RESULTS_GRAPH:
case RASQAL_QUERY_RESULTS_SYNTAX:
case RASQAL_QUERY_RESULTS_UNKNOWN:
/* failure */
fprintf(stderr, "%s: Query result format %d cannot be tested.",
program, results_type);
rc = 1;
goto tidy_setup;
break;
}
} else
rc = 1;
if(verbose) {
fprintf(stdout, "%s: Result: %s\n", program, rc ? "FAILURE" : "success");
}
if(results) {
rasqal_free_query_results(results); results = NULL;
}
tidy_query:
if(rq)
rasqal_free_query(rq);
tidy_setup:
if(expected_results)
rasqal_free_query_results(expected_results);
if(results)
rasqal_free_query_results(results);
if(result_iostr)
raptor_free_iostream(result_iostr);
if(ds)
rasqal_free_dataset(ds);
if(free_query_base_uri_string)
raptor_free_memory(query_base_uri_string);
if(query_base_uri)
raptor_free_uri(query_base_uri);
if(data_graphs)
raptor_free_sequence(data_graphs);
rasqal_free_world(world);
return (rc);
}
/**
* rasqal_variables_table_add:
* @vt: #rasqal_variables_table to associate the variable with
* @type: variable type defined by enumeration rasqal_variable_type
* @name: variable name
* @value: variable #rasqal_literal value (or NULL)
*
* Constructor - Create a new variable and add it to the variables table
*
* The @name and @value become owned by the rasqal_variable structure
*
* Return value: a new #rasqal_variable or NULL on failure.
**/
rasqal_variable*
rasqal_variables_table_add(rasqal_variables_table* vt,
rasqal_variable_type type,
const unsigned char *name, rasqal_literal *value)
{
int i;
rasqal_variable* v;
raptor_sequence* seq = NULL;
int* count_p = NULL;
if(!vt)
return NULL;
switch(type) {
case RASQAL_VARIABLE_TYPE_ANONYMOUS:
seq = vt->anon_variables_sequence;
count_p = &vt->anon_variables_count;
break;
case RASQAL_VARIABLE_TYPE_NORMAL:
seq = vt->variables_sequence;
count_p = &vt->variables_count;
break;
case RASQAL_VARIABLE_TYPE_UNKNOWN:
default:
RASQAL_DEBUG2("Unknown variable type %d", type);
return NULL;
}
for(i = 0; i < raptor_sequence_size(seq); i++) {
v = (rasqal_variable*)raptor_sequence_get_at(seq, i);
if(!strcmp((const char*)v->name, (const char*)name)) {
/* name already present, do not need a copy */
RASQAL_FREE(cstring, name);
return v;
}
}
v = (rasqal_variable*)RASQAL_CALLOC(rasqal_variable, 1,
sizeof(rasqal_variable));
if(v) {
v->vars_table = vt;
v->type= type;
v->name= name;
v->value= value;
if(count_p)
v->offset= (*count_p);
if(seq && raptor_sequence_push(seq, v))
return NULL;
if(type == RASQAL_VARIABLE_TYPE_ANONYMOUS) {
/* new anon variable: add base offset */
v->offset += vt->variables_count;
} else {
/* new normal variable: move all anon variable offsets up 1 */
for(i = 0; i < vt->anon_variables_count; i++) {
rasqal_variable* anon_v;
anon_v = (rasqal_variable*)raptor_sequence_get_at(vt->anon_variables_sequence, i);
anon_v->offset++;
}
}
/* Increment count and free var names only after sequence push succeeded */
if(count_p)
(*count_p)++;
if(vt->variable_names) {
RASQAL_FREE(cstrings, vt->variable_names);
vt->variable_names = NULL;
}
} else {
RASQAL_FREE(cstring, name);
if(value)
rasqal_free_literal(value);
}
return v;
}
int
main(int argc, char *argv[])
{
const char *program = rasqal_basename(argv[0]);
rasqal_rowsource *rowsource = NULL;
rasqal_world* world = NULL;
rasqal_query* query = NULL;
raptor_sequence* row_seq = NULL;
raptor_sequence* expr_seq = NULL;
int failures = 0;
rasqal_variables_table* vt;
rasqal_rowsource *input_rs = NULL;
int vars_count;
raptor_sequence* vars_seq = NULL;
int test_id;
world = rasqal_new_world();
if(!world || rasqal_world_open(world)) {
fprintf(stderr, "%s: rasqal_world init failed\n", program);
return(1);
}
query = rasqal_new_query(world, "sparql", NULL);
vt = query->vars_table;
for(test_id = 0; test_id < GROUP_TESTS_COUNT; test_id++) {
int expected_rows_count = test_data[test_id].rows;
int expected_vars_count = test_data[test_id].vars;
const int* expected_group_ids = test_data[test_id].group_ids;
int expected_ngroups = test_data[test_id].ngroups;
raptor_sequence* seq = NULL;
int count;
int size;
int i;
int groups_counted;
int last_group_id;
vars_count = expected_vars_count;
row_seq = rasqal_new_row_sequence(world, vt, test_data[test_id].data,
vars_count, &vars_seq);
if(row_seq) {
input_rs = rasqal_new_rowsequence_rowsource(world, query, vt,
row_seq, vars_seq);
/* vars_seq and row_seq are now owned by input_rs */
vars_seq = row_seq = NULL;
}
if(!input_rs) {
fprintf(stderr, "%s: failed to create rowsequence rowsource\n", program);
failures++;
goto tidy;
}
#ifdef HAVE_RAPTOR2_API
expr_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_expression,
(raptor_data_print_handler)rasqal_expression_print);
#else
expr_seq = raptor_new_sequence((raptor_sequence_free_handler*)rasqal_free_expression,
(raptor_sequence_print_handler*)rasqal_expression_print);
#endif
if(test_data[test_id].expr_vars[0] != NULL) {
int vindex;
const unsigned char* var_name;
for(vindex = 0;
(var_name = (const unsigned char*)test_data[test_id].expr_vars[vindex] );
vindex++) {
rasqal_variable* v;
rasqal_literal *l = NULL;
rasqal_expression* e = NULL;
v = rasqal_variables_table_get_by_name(vt, var_name);
if(v)
l = rasqal_new_variable_literal(world, v);
if(l)
e = rasqal_new_literal_expression(world, l);
if(e)
raptor_sequence_push(expr_seq, e);
else {
fprintf(stderr, "%s: failed to create variable %s\n", program,
(const char*)var_name);
failures++;
goto tidy;
}
}
}
rowsource = rasqal_new_groupby_rowsource(world, query, input_rs, expr_seq);
/* input_rs is now owned by rowsource */
input_rs = NULL;
if(!rowsource) {
fprintf(stderr, "%s: failed to create groupby rowsource\n", program);
failures++;
goto tidy;
}
seq = rasqal_rowsource_read_all_rows(rowsource);
if(!seq) {
fprintf(stderr,
"%s: test %d rasqal_rowsource_read_all_rows() returned a NULL seq for a groupby rowsource\n",
program, test_id);
failures++;
goto tidy;
}
count = raptor_sequence_size(seq);
if(count != expected_rows_count) {
fprintf(stderr,
"%s: test %d rasqal_rowsource_read_all_rows() returned %d rows for a groupby rowsource, expected %d\n",
program, test_id, count, expected_rows_count);
failures++;
goto tidy;
}
size = rasqal_rowsource_get_size(rowsource);
if(size != expected_vars_count) {
fprintf(stderr,
"%s: test %d rasqal_rowsource_get_size() returned %d columns (variables) for a groupby rowsource, expected %d\n",
program, test_id, size, expected_vars_count);
failures++;
goto tidy;
}
groups_counted = 0;
last_group_id = -1;
for(i = 0; i < count; i++) {
rasqal_row* row = raptor_sequence_get_at(seq, i);
if(row->group_id != last_group_id) {
groups_counted++;
last_group_id = row->group_id;
}
if(row->group_id != expected_group_ids[i]) {
fprintf(stderr, "%s: test %d row #%d has group_id %d, expected %d\n",
program, test_id, i, row->group_id, expected_group_ids[i]);
failures++;
goto tidy;
}
}
if(groups_counted != expected_ngroups) {
fprintf(stderr, "%s: test %d returnd %d groups, expected %d\n",
program, test_id, groups_counted, expected_ngroups);
failures++;
goto tidy;
}
#ifdef RASQAL_DEBUG
rasqal_rowsource_print_row_sequence(rowsource, seq, stderr);
#endif
raptor_free_sequence(seq); seq = NULL;
rasqal_free_rowsource(rowsource); rowsource = NULL;
if(expr_seq)
raptor_free_sequence(expr_seq);
expr_seq = NULL;
}
tidy:
if(expr_seq)
raptor_free_sequence(expr_seq);
if(rowsource)
rasqal_free_rowsource(rowsource);
if(input_rs)
rasqal_free_rowsource(input_rs);
if(query)
rasqal_free_query(query);
if(world)
rasqal_free_world(world);
return failures;
}
int
main(int argc, char *argv[])
{
int query_from_string = 0;
unsigned char *query_string = NULL;
unsigned char *uri_string = NULL;
int free_uri_string = 0;
unsigned char *base_uri_string = NULL;
rasqal_query *rq = NULL;
rasqal_query_results *results;
const char *ql_name = "sparql";
char *ql_uri = NULL;
int rc = 0;
raptor_uri *uri = NULL;
raptor_uri *base_uri = NULL;
char *filename = NULL;
char *p;
int usage = 0;
int help = 0;
int quiet = 0;
int count = 0;
int dryrun = 0;
raptor_sequence* data_graphs = NULL;
const char *result_format = NULL;
query_output_format output_format = QUERY_OUTPUT_UNKNOWN;
rasqal_feature query_feature = (rasqal_feature)-1;
int query_feature_value= -1;
unsigned char* query_feature_string_value = NULL;
rasqal_world *world;
raptor_world* raptor_world_ptr = NULL;
#ifdef RASQAL_INTERNAL
int store_results = -1;
#endif
char* data_graph_parser_name = NULL;
raptor_iostream* iostr = NULL;
const unsigned char* service_uri_string = 0;
raptor_uri* service_uri = NULL;
program = argv[0];
if((p = strrchr(program, '/')))
program = p + 1;
else if((p = strrchr(program, '\\')))
program = p + 1;
argv[0] = program;
world = rasqal_new_world();
if(!world || rasqal_world_open(world)) {
fprintf(stderr, "%s: rasqal_world init failed\n", program);
return(1);
}
raptor_world_ptr = rasqal_world_get_raptor(world);
rasqal_world_set_log_handler(world, world, roqet_log_handler);
#ifdef STORE_RESULTS_FLAG
/* This is for debugging only */
if(1) {
char* sr = getenv("RASQAL_DEBUG_STORE_RESULTS");
if(sr)
store_results = atoi(sr);
}
#endif
while (!usage && !help)
{
int c;
#ifdef HAVE_GETOPT_LONG
int option_index = 0;
c = getopt_long (argc, argv, GETOPT_STRING, long_options, &option_index);
#else
c = getopt (argc, argv, GETOPT_STRING);
#endif
if (c == -1)
break;
switch (c) {
case 0:
case '?': /* getopt() - unknown option */
usage = 1;
break;
case 'c':
count = 1;
break;
case 'd':
output_format = QUERY_OUTPUT_UNKNOWN;
if(optarg) {
int i;
for(i = 1; i <= QUERY_OUTPUT_LAST; i++)
if(!strcmp(optarg, query_output_format_labels[i][0])) {
output_format = (query_output_format)i;
break;
}
}
if(output_format == QUERY_OUTPUT_UNKNOWN) {
int i;
fprintf(stderr,
"%s: invalid argument `%s' for `" HELP_ARG(d, dump-query) "'\n",
program, optarg);
for(i = 1; i <= QUERY_OUTPUT_LAST; i++)
fprintf(stderr,
" %-12s for %s\n", query_output_format_labels[i][0],
query_output_format_labels[i][1]);
usage = 1;
}
break;
case 'e':
if(optarg) {
query_string = (unsigned char*)optarg;
query_from_string = 1;
}
break;
case 'f':
if(optarg) {
if(!strcmp(optarg, "help")) {
int i;
fprintf(stderr, "%s: Valid query features are:\n", program);
for(i = 0; i < (int)rasqal_get_feature_count(); i++) {
const char *feature_name;
const char *feature_label;
if(!rasqal_features_enumerate(world, (rasqal_feature)i,
&feature_name, NULL,
&feature_label)) {
const char *feature_type;
feature_type = (rasqal_feature_value_type((rasqal_feature)i) == 0) ? "" : " (string)";
fprintf(stderr, " %-20s %s%s\n", feature_name, feature_label,
feature_type);
}
}
fputs("Features are set with `" HELP_ARG(f, feature) " FEATURE=VALUE or `-f FEATURE'\nand take a decimal integer VALUE except where noted, defaulting to 1 if omitted.\n", stderr);
rasqal_free_world(world);
exit(0);
} else {
int i;
size_t arg_len = strlen(optarg);
for(i = 0; i < (int)rasqal_get_feature_count(); i++) {
const char *feature_name;
size_t len;
if(rasqal_features_enumerate(world, (rasqal_feature)i,
&feature_name, NULL, NULL))
continue;
len = strlen(feature_name);
if(!strncmp(optarg, feature_name, len)) {
query_feature = (rasqal_feature)i;
if(rasqal_feature_value_type(query_feature) == 0) {
if(len < arg_len && optarg[len] == '=')
query_feature_value=atoi(&optarg[len + 1]);
else if(len == arg_len)
query_feature_value = 1;
} else {
if(len < arg_len && optarg[len] == '=')
query_feature_string_value = (unsigned char*)&optarg[len + 1];
else if(len == arg_len)
query_feature_string_value = (unsigned char*)"";
}
break;
}
}
if(query_feature_value < 0 && !query_feature_string_value) {
fprintf(stderr, "%s: invalid argument `%s' for `" HELP_ARG(f, feature) "'\nTry '%s " HELP_ARG(f, feature) " help' for a list of valid features\n",
program, optarg, program);
usage = 1;
}
}
}
break;
case 'F':
if(optarg) {
if(!raptor_world_is_parser_name(raptor_world_ptr, optarg)) {
fprintf(stderr,
"%s: invalid parser name `%s' for `" HELP_ARG(F, format) "'\n\n",
program, optarg);
usage = 1;
} else {
data_graph_parser_name = optarg;
}
}
break;
case 'h':
help = 1;
break;
case 'n':
dryrun = 1;
break;
case 'p':
if(optarg)
service_uri_string = (const unsigned char*)optarg;
break;
case 'r':
if(optarg)
result_format = optarg;
break;
case 'i':
if(rasqal_language_name_check(world, optarg))
ql_name = optarg;
else {
int i;
fprintf(stderr,
"%s: invalid argument `%s' for `" HELP_ARG(i, input) "'\n",
program, optarg);
fprintf(stderr, "Valid arguments are:\n");
for(i = 0; 1; i++) {
const raptor_syntax_description* desc;
desc = rasqal_world_get_query_language_description(world, i);
if(desc == NULL)
break;
fprintf(stderr, " %-18s for %s\n", desc->names[0], desc->label);
}
usage = 1;
}
break;
case 'q':
quiet = 1;
break;
case 's':
case 'D':
case 'G':
if(optarg) {
rasqal_data_graph *dg = NULL;
rasqal_data_graph_flags type;
type = (c == 's' || c == 'G') ? RASQAL_DATA_GRAPH_NAMED :
RASQAL_DATA_GRAPH_BACKGROUND;
if(!strcmp((const char*)optarg, "-")) {
/* stdin: use an iostream not a URI data graph */
unsigned char* source_uri_string;
raptor_uri* iostr_base_uri = NULL;
raptor_uri* graph_name = NULL;
/* FIXME - get base URI from somewhere else */
source_uri_string = (unsigned char*)"file:///dev/stdin";
iostr_base_uri = raptor_new_uri(raptor_world_ptr, source_uri_string);
if(iostr_base_uri) {
iostr = raptor_new_iostream_from_file_handle(raptor_world_ptr,
stdin);
if(iostr)
dg = rasqal_new_data_graph_from_iostream(world,
iostr, iostr_base_uri,
graph_name,
type,
NULL,
data_graph_parser_name,
NULL);
}
if(base_uri)
raptor_free_uri(base_uri);
} else if(!access((const char*)optarg, R_OK)) {
/* file: use URI */
unsigned char* source_uri_string;
raptor_uri* source_uri;
raptor_uri* graph_name = NULL;
source_uri_string = raptor_uri_filename_to_uri_string((const char*)optarg);
source_uri = raptor_new_uri(raptor_world_ptr, source_uri_string);
raptor_free_memory(source_uri_string);
if(type == RASQAL_DATA_GRAPH_NAMED)
graph_name = source_uri;
if(source_uri)
dg = rasqal_new_data_graph_from_uri(world,
source_uri,
graph_name,
type,
NULL, data_graph_parser_name,
NULL);
if(source_uri)
raptor_free_uri(source_uri);
} else {
raptor_uri* source_uri;
raptor_uri* graph_name = NULL;
/* URI: use URI */
source_uri = raptor_new_uri(raptor_world_ptr,
(const unsigned char*)optarg);
if(type == RASQAL_DATA_GRAPH_NAMED)
graph_name = source_uri;
if(source_uri)
dg = rasqal_new_data_graph_from_uri(world,
source_uri,
graph_name,
type,
NULL, data_graph_parser_name,
NULL);
if(source_uri)
raptor_free_uri(source_uri);
}
if(!dg) {
fprintf(stderr, "%s: Failed to create data graph for `%s'\n",
program, optarg);
return(1);
}
if(!data_graphs) {
data_graphs = raptor_new_sequence((raptor_data_free_handler)rasqal_free_data_graph,
NULL);
if(!data_graphs) {
fprintf(stderr, "%s: Failed to create data graphs sequence\n",
program);
return(1);
}
}
raptor_sequence_push(data_graphs, dg);
}
break;
case 'W':
if(optarg)
warning_level = atoi(optarg);
else
warning_level = 0;
rasqal_world_set_warning_level(world, warning_level);
break;
case 'E':
ignore_errors = 1;
break;
case 'v':
fputs(rasqal_version_string, stdout);
fputc('\n', stdout);
rasqal_free_world(world);
exit(0);
#ifdef STORE_RESULTS_FLAG
case STORE_RESULTS_FLAG:
store_results = (!strcmp(optarg, "yes") || !strcmp(optarg, "YES"));
break;
#endif
}
}
if(!help && !usage) {
if(service_uri_string) {
if(optind != argc && optind != argc-1)
usage = 2; /* Title and usage */
} else if(query_string) {
if(optind != argc && optind != argc-1)
usage = 2; /* Title and usage */
} else {
if(optind != argc-1 && optind != argc-2)
usage = 2; /* Title and usage */
}
}
if(usage) {
if(usage > 1) {
fprintf(stderr, title_format_string, rasqal_version_string);
fputs("Rasqal home page: ", stderr);
fputs(rasqal_home_url_string, stderr);
fputc('\n', stderr);
fputs(rasqal_copyright_string, stderr);
fputs("\nLicense: ", stderr);
fputs(rasqal_license_string, stderr);
fputs("\n\n", stderr);
}
fprintf(stderr, "Try `%s " HELP_ARG(h, help) "' for more information.\n",
program);
rasqal_free_world(world);
exit(1);
}
if(help) {
int i;
printf(title_format_string, rasqal_version_string);
puts("Run an RDF query giving variable bindings or RDF triples.");
printf("Usage: %s [OPTIONS] <query URI> [base URI]\n", program);
printf(" %s [OPTIONS] -e <query string> [base URI]\n", program);
printf(" %s [OPTIONS] -p <SPARQL protocol service URI> -e <query string> [base URI]\n\n", program);
fputs(rasqal_copyright_string, stdout);
fputs("\nLicense: ", stdout);
puts(rasqal_license_string);
fputs("Rasqal home page: ", stdout);
puts(rasqal_home_url_string);
puts("\nNormal operation is to execute the query retrieved from URI <query URI>");
puts("and print the results in a simple text format.");
puts("\nMain options:");
puts(HELP_TEXT("e", "exec QUERY ", "Execute QUERY string instead of <query URI>"));
puts(HELP_TEXT("p", "protocol URI ", "Execute QUERY against a SPARQL protocol service URI"));
puts(HELP_TEXT("i", "input LANGUAGE ", "Set query language name to one of:"));
for(i = 0; 1; i++) {
const raptor_syntax_description* desc;
desc = rasqal_world_get_query_language_description(world, i);
if(!desc)
break;
printf(" %-15s %s", desc->names[0], desc->label);
if(!i)
puts(" (default)");
else
putchar('\n');
}
puts(HELP_TEXT("r", "results FORMAT ", "Set query results output format to one of:"));
puts(" For variable bindings and boolean results:");
puts(" simple A simple text format (default)");
for(i = 0; 1; i++) {
const raptor_syntax_description* desc;
desc = rasqal_world_get_query_results_format_description(world, i);
if(!desc)
break;
if(desc->flags & RASQAL_QUERY_RESULTS_FORMAT_FLAG_WRITER)
printf(" %-10s %s\n", desc->names[0], desc->label);
}
puts(" For RDF graph results:");
for(i = 0; 1; i++) {
const raptor_syntax_description *desc;
desc = raptor_world_get_parser_description(raptor_world_ptr, i);
if(!desc)
break;
printf(" %-15s %s", desc->names[0], desc->label);
if(!i)
puts(" (default)");
else
putchar('\n');
}
puts("\nAdditional options:");
puts(HELP_TEXT("c", "count ", "Count triples - no output"));
puts(HELP_TEXT("d FORMAT", "dump-query FORMAT", HELP_PAD "Print the parsed query out in FORMAT:"));
puts(HELP_TEXT("D URI", "data URI ", "RDF data source URI"));
for(i = 1; i <= QUERY_OUTPUT_LAST; i++)
printf(" %-15s %s\n", query_output_format_labels[i][0],
query_output_format_labels[i][1]);
puts(HELP_TEXT("E", "ignore-errors ", "Ignore error messages"));
puts(HELP_TEXT("f FEATURE(=VALUE)", "feature FEATURE(=VALUE)", HELP_PAD "Set query features" HELP_PAD "Use `-f help' for a list of valid features"));
puts(HELP_TEXT("F NAME", "format NAME ", "Set data source format name (default: guess)"));
puts(HELP_TEXT("G URI", "named URI ", "RDF named graph data source URI"));
puts(HELP_TEXT("h", "help ", "Print this help, then exit"));
puts(HELP_TEXT("n", "dryrun ", "Prepare but do not run the query"));
puts(HELP_TEXT("q", "quiet ", "No extra information messages"));
puts(HELP_TEXT("s URI", "source URI ", "Same as `-G URI'"));
puts(HELP_TEXT("v", "version ", "Print the Rasqal version"));
puts(HELP_TEXT("w", "walk-query ", "Print query. Same as '-d structure'"));
puts(HELP_TEXT("W LEVEL", "warnings LEVEL", HELP_PAD "Set warning message LEVEL from 0: none to 100: all"));
#ifdef STORE_RESULTS_FLAG
puts(HELP_TEXT_LONG("store-results BOOL", "DEBUG: Set store results yes/no BOOL"));
#endif
puts("\nReport bugs to http://bugs.librdf.org/");
rasqal_free_world(world);
exit(0);
}
if(service_uri_string) {
service_uri = raptor_new_uri(raptor_world_ptr, service_uri_string);
if(optind == argc-1) {
base_uri_string = (unsigned char*)argv[optind];
}
} else if(query_string) {
if(optind == argc-1)
base_uri_string = (unsigned char*)argv[optind];
} else {
if(optind == argc-1)
uri_string = (unsigned char*)argv[optind];
else {
uri_string = (unsigned char*)argv[optind++];
base_uri_string = (unsigned char*)argv[optind];
}
/* If uri_string is "path-to-file", turn it into a file: URI */
if(!strcmp((const char*)uri_string, "-")) {
if(!base_uri_string) {
fprintf(stderr, "%s: A Base URI is required when reading from standard input.\n",
program);
return(1);
}
uri_string = NULL;
} else if(!access((const char*)uri_string, R_OK)) {
filename = (char*)uri_string;
uri_string = raptor_uri_filename_to_uri_string(filename);
free_uri_string = 1;
}
if(uri_string) {
uri = raptor_new_uri(raptor_world_ptr, uri_string);
if(!uri) {
fprintf(stderr, "%s: Failed to create URI for %s\n",
program, uri_string);
return(1);
}
} else
uri = NULL; /* stdin */
}
if(!base_uri_string) {
if(uri)
base_uri = raptor_uri_copy(uri);
} else
base_uri = raptor_new_uri(raptor_world_ptr, base_uri_string);
if(base_uri_string && !base_uri) {
fprintf(stderr, "%s: Failed to create URI for %s\n",
program, base_uri_string);
return(1);
}
if(service_uri_string) {
/* NOP - nothing to do here */
} else if(query_string) {
/* NOP - already got it */
} else if(!uri_string) {
size_t read_len;
query_string = (unsigned char*)calloc(FILE_READ_BUF_SIZE, 1);
read_len = fread(query_string, FILE_READ_BUF_SIZE, 1, stdin);
if(read_len < FILE_READ_BUF_SIZE) {
if(ferror(stdin))
fprintf(stderr, "%s: query string stdin read failed - %s\n",
program, strerror(errno));
else
fprintf(stderr, "%s: query string stdin read failed - no error\n",
program);
rc = 1;
goto tidy_setup;
}
query_from_string = 0;
} else if(filename) {
raptor_stringbuffer *sb = raptor_new_stringbuffer();
size_t len;
FILE *fh;
unsigned char* buffer;
fh = fopen(filename, "r");
if(!fh) {
fprintf(stderr, "%s: file '%s' open failed - %s",
program, filename, strerror(errno));
rc = 1;
goto tidy_setup;
}
buffer = (unsigned char*)malloc(FILE_READ_BUF_SIZE);
while(!feof(fh)) {
size_t read_len;
read_len = fread((char*)buffer, 1, FILE_READ_BUF_SIZE, fh);
if(read_len > 0)
raptor_stringbuffer_append_counted_string(sb, buffer, read_len, 1);
if(read_len < FILE_READ_BUF_SIZE) {
if(ferror(fh)) {
fprintf(stderr, "%s: file '%s' read failed - %s\n",
program, filename, strerror(errno));
free(buffer);
fclose(fh);
rc = 1;
goto tidy_setup;
}
break;
}
}
free(buffer);
fclose(fh);
len = raptor_stringbuffer_length(sb);
query_string = (unsigned char*)malloc(len + 1);
raptor_stringbuffer_copy_to_string(sb, query_string, len);
raptor_free_stringbuffer(sb);
query_from_string = 0;
} else {
raptor_www *www;
www = raptor_new_www(raptor_world_ptr);
if(www) {
raptor_www_fetch_to_string(www, uri, (void**)&query_string, NULL, malloc);
raptor_free_www(www);
}
if(!query_string || error_count) {
fprintf(stderr, "%s: Retrieving query at URI '%s' failed\n",
program, uri_string);
rc = 1;
goto tidy_setup;
}
query_from_string = 0;
}
if(!quiet) {
if(service_uri) {
fprintf(stderr, "%s: Calling SPARQL service at URI %s", program,
service_uri_string);
if(query_string)
fprintf(stderr, " with query '%s'", query_string);
if(base_uri_string)
fprintf(stderr, " with base URI %s\n", base_uri_string);
fputc('\n', stderr);
} else if(query_from_string) {
if(base_uri_string)
fprintf(stderr, "%s: Running query '%s' with base URI %s\n", program,
query_string, base_uri_string);
else
fprintf(stderr, "%s: Running query '%s'\n", program,
query_string);
} else if(filename) {
if(base_uri_string)
fprintf(stderr, "%s: Querying from file %s with base URI %s\n", program,
filename, base_uri_string);
else
fprintf(stderr, "%s: Querying from file %s\n", program, filename);
} else if(uri_string) {
if(base_uri_string)
fprintf(stderr, "%s: Querying URI %s with base URI %s\n", program,
uri_string, base_uri_string);
else
fprintf(stderr, "%s: Querying URI %s\n", program, uri_string);
}
}
if(service_uri) {
/* Execute query remotely */
if(!dryrun)
results = roqet_call_sparql_service(world, service_uri, query_string,
data_graphs,
/* service_format */ NULL);
} else {
/* Execute query in this query engine (from URI or from -e QUERY) */
rq = roqet_init_query(world,
ql_name, ql_uri, query_string,
base_uri,
query_feature, query_feature_value,
query_feature_string_value,
store_results,
data_graphs);
if(!rq) {
rc = 1;
goto tidy_query;
}
if(output_format != QUERY_OUTPUT_UNKNOWN && !quiet)
roqet_print_query(rq, raptor_world_ptr, output_format, base_uri);
if(!dryrun) {
results = rasqal_query_execute(rq);
}
}
/* No results from dryrun */
if(dryrun)
goto tidy_query;
if(!results) {
fprintf(stderr, "%s: Query execution failed\n", program);
rc = 1;
goto tidy_query;
}
if(rasqal_query_results_is_bindings(results)) {
if(result_format)
rc = print_formatted_query_results(world, results,
raptor_world_ptr, stdout,
result_format, base_uri, quiet);
else
print_bindings_result_simple(results, stdout, quiet, count);
} else if(rasqal_query_results_is_boolean(results)) {
if(result_format)
rc = print_formatted_query_results(world, results,
raptor_world_ptr, stdout,
result_format, base_uri, quiet);
else
print_boolean_result_simple(results, stdout, quiet);
} else if(rasqal_query_results_is_graph(results)) {
if(!result_format)
result_format = DEFAULT_GRAPH_FORMAT;
rc = print_graph_result(rq, results, raptor_world_ptr,
stdout, result_format, base_uri, quiet);
} else {
fprintf(stderr, "%s: Query returned unknown result format\n", program);
rc = 1;
}
rasqal_free_query_results(results);
tidy_query:
if(!query_from_string)
free(query_string);
if(rq)
rasqal_free_query(rq);
tidy_setup:
if(data_graphs)
raptor_free_sequence(data_graphs);
if(base_uri)
raptor_free_uri(base_uri);
if(uri)
raptor_free_uri(uri);
if(free_uri_string)
raptor_free_memory(uri_string);
if(iostr)
raptor_free_iostream(iostr);
if(service_uri)
raptor_free_uri(service_uri);
rasqal_free_world(world);
if(error_count && !ignore_errors)
return 1;
if(warning_count && warning_level != 0)
return 2;
return (rc);
}
/**
* rasqal_rowsource_read_all_rows:
* @rowsource: rasqal rowsource
*
* Read all rows from a rowsource
*
* After calling this, the rowsource will be empty of rows and finished
* and if a sequence is returned, it is owned by the caller.
*
* Return value: new sequence of all rows (may be size 0) or NULL on failure
**/
raptor_sequence*
rasqal_rowsource_read_all_rows(rasqal_rowsource *rowsource)
{
raptor_sequence* seq;
if(!rowsource)
return NULL;
if(rowsource->flags & RASQAL_ROWSOURCE_FLAGS_SAVED_ROWS) {
raptor_sequence* new_seq;
/* Return a complete copy of all previously saved rows */
seq = rowsource->rows_sequence;
new_seq = rasqal_row_sequence_copy(seq);
RASQAL_DEBUG4("%s rowsource %p returning a sequence of %d saved rows\n",
rowsource->handler->name, rowsource,
raptor_sequence_size(new_seq));
return new_seq;
}
/* Execute */
if(rasqal_rowsource_ensure_variables(rowsource))
return NULL;
if(rowsource->handler->read_all_rows) {
seq = rowsource->handler->read_all_rows(rowsource, rowsource->user_data);
if(!seq) {
seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_row,
(raptor_data_print_handler)rasqal_row_print);
} else if(rowsource->generate_group) {
int i;
rasqal_row* row;
/* Set group for all rows if there are no groups returned */
for(i = 0; (row = (rasqal_row*)raptor_sequence_get_at(seq, i)); i++) {
/* if first row has a group ID, end */
if(!i && row->group_id >= 0)
break;
row->group_id = 0;
}
}
goto done;
}
seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_row,
(raptor_data_print_handler)rasqal_row_print);
if(!seq)
return NULL;
while(1) {
rasqal_row* row = rasqal_rowsource_read_row(rowsource);
if(!row)
break;
/* Generate a group around all rows if there are no groups returned */
if(rowsource->generate_group && row->group_id < 0)
row->group_id = 0;
raptor_sequence_push(seq, row);
}
done:
if(seq && rowsource->flags & RASQAL_ROWSOURCE_FLAGS_SAVE_ROWS) {
raptor_sequence* new_seq;
/* Save a complete copy of all rows */
new_seq = rasqal_row_sequence_copy(seq);
RASQAL_DEBUG4("%s rowsource %p saving a sequence of %d rows\n",
rowsource->handler->name, rowsource,
raptor_sequence_size(new_seq));
rowsource->rows_sequence = new_seq;
rowsource->flags |= RASQAL_ROWSOURCE_FLAGS_SAVED_ROWS;
}
RASQAL_DEBUG4("%s rowsource %p returning a sequence of %d rows\n",
rowsource->handler->name, rowsource,
raptor_sequence_size(seq));
return seq;
}
static int
rasqal_groupby_rowsource_process(rasqal_rowsource* rowsource,
rasqal_groupby_rowsource_context* con)
{
/* already processed */
if(con->processed)
return 0;
con->processed = 1;
/* Empty expression list - no need to read rows */
if(!con->expr_seq || !con->expr_seq_size) {
con->group_id++;
return 0;
}
con->tree = raptor_new_avltree(rasqal_rowsource_groupby_literal_sequence_compare,
(raptor_data_free_handler)rasqal_free_groupby_tree_node,
/* flags */ 0);
if(!con->tree)
return 1;
raptor_avltree_set_print_handler(con->tree,
rasqal_rowsource_groupby_tree_print_node);
while(1) {
rasqal_row* row;
row = rasqal_rowsource_read_row(con->rowsource);
if(!row)
break;
rasqal_row_bind_variables(row, rowsource->query->vars_table);
if(con->expr_seq) {
raptor_sequence* literal_seq;
rasqal_groupby_tree_node key;
rasqal_groupby_tree_node* node;
literal_seq = rasqal_expression_sequence_evaluate(rowsource->query,
con->expr_seq,
/* ignore_errors */ 0,
/* literal_seq */ NULL,
/* error_p */ NULL);
if(!literal_seq) {
/* FIXME - what to do on errors? */
continue;
}
memset(&key, '\0', sizeof(key));
key.con = con;
key.literals = literal_seq;
node = (rasqal_groupby_tree_node*)raptor_avltree_search(con->tree, &key);
if(!node) {
/* New Group */
node = (rasqal_groupby_tree_node*)RASQAL_CALLOC(rasqal_groupby_tree_node, sizeof(*node), 1);
if(!node) {
raptor_free_sequence(literal_seq);
return 1;
}
node->con = con;
node->group_id = ++con->group_id;
/* node now owns literal_seq */
node->literals = literal_seq;
#ifdef HAVE_RAPTOR2_API
node->rows = raptor_new_sequence((raptor_data_free_handler)rasqal_free_row, (raptor_data_print_handler)rasqal_row_print);
#else
node->rows = raptor_new_sequence((raptor_sequence_free_handler*)rasqal_free_row, (raptor_sequence_print_handler*)rasqal_row_print);
#endif
if(!node->rows) {
rasqal_free_groupby_tree_node(node);
return 1;
}
/* after this, node is owned by con->tree */
raptor_avltree_add(con->tree, node);
} else
raptor_free_sequence(literal_seq);
row->group_id = node->group_id;
/* after this, node owns the row */
raptor_sequence_push(node->rows, row);
}
}
#ifdef RASQAL_DEBUG
if(con->tree) {
fputs("Grouping ", DEBUG_FH);
raptor_avltree_print(con->tree, DEBUG_FH);
fputs("\n", DEBUG_FH);
}
#endif
con->group_iterator = raptor_new_avltree_iterator(con->tree,
NULL, NULL,
1);
con->group_row_index = 0;
con->offset = 0;
return 0;
}
static void
rasqal_sparql_xml_sax2_end_element_handler(void *user_data,
raptor_xml_element* xml_element)
{
rasqal_rowsource_sparql_xml_context* con;
raptor_qname* name;
int i;
rasqal_sparql_xml_read_state state=STATE_unknown;
con=(rasqal_rowsource_sparql_xml_context*)user_data;
name=raptor_xml_element_get_name(xml_element);
for(i=STATE_first; i <= STATE_last; i++) {
if(!strcmp((const char*)raptor_qname_get_local_name(name),
sparql_xml_element_names[i])) {
state=(rasqal_sparql_xml_read_state)i;
con->state=state;
}
}
if(state == STATE_unknown) {
fprintf(stderr, "UNKNOWN element %s\n", raptor_qname_get_local_name(name));
con->failed++;
}
con->depth--;
#ifdef TRACE_XML
if(con->trace) {
pad(stderr, con->depth);
fprintf(stderr, "End Element %s (%d)\n", raptor_qname_get_local_name(name),
con->state);
}
#endif
switch(con->state) {
case STATE_head:
/* Only now is the full number of variables known */
con->variables_count = rasqal_variables_table_get_named_variables_count(con->vars_table);
con->rowsource->size = con->variables_count;
break;
case STATE_literal:
if(1) {
rasqal_literal* l;
unsigned char* lvalue;
raptor_uri* datatype_uri=NULL;
char* language_str=NULL;
lvalue=(unsigned char*)RASQAL_MALLOC(cstring, con->value_len+1);
memcpy(lvalue, con->value, con->value_len + 1);
if(con->datatype)
datatype_uri = raptor_new_uri(con->world->raptor_world_ptr, (const unsigned char*)con->datatype);
if(con->language) {
size_t language_len = strlen(con->language);
language_str=(char*)RASQAL_MALLOC(cstring, language_len + 1);
memcpy(language_str, con->language, language_len + 1);
}
l = rasqal_new_string_literal_node(con->world, lvalue, language_str,
datatype_uri);
rasqal_row_set_value_at(con->row, con->result_offset, l);
rasqal_free_literal(l);
RASQAL_DEBUG3("Saving row result %d string value at offset %d\n",
con->offset, con->result_offset);
}
break;
case STATE_bnode:
if(1) {
rasqal_literal* l;
unsigned char* lvalue;
lvalue=(unsigned char*)RASQAL_MALLOC(cstring, con->value_len+1);
memcpy(lvalue, con->value, con->value_len + 1);
l = rasqal_new_simple_literal(con->world, RASQAL_LITERAL_BLANK, lvalue);
rasqal_row_set_value_at(con->row, con->result_offset, l);
rasqal_free_literal(l);
RASQAL_DEBUG3("Saving row result %d bnode value at offset %d\n",
con->offset, con->result_offset);
}
break;
case STATE_uri:
if(1) {
raptor_uri* uri;
rasqal_literal* l;
uri = raptor_new_uri(con->world->raptor_world_ptr, (const unsigned char*)con->value);
l = rasqal_new_uri_literal(con->world, uri);
rasqal_row_set_value_at(con->row, con->result_offset, l);
rasqal_free_literal(l);
RASQAL_DEBUG3("Saving row result %d uri value at offset %d\n",
con->offset, con->result_offset);
}
break;
case STATE_result:
if(con->row) {
RASQAL_DEBUG2("Saving row result %d\n", con->offset);
raptor_sequence_push(con->results_sequence, con->row);
}
con->row=NULL;
break;
case STATE_unknown:
case STATE_sparql:
case STATE_variable:
case STATE_results:
case STATE_binding:
default:
break;
}
if(con->value) {
RASQAL_FREE(cstring, con->value);
con->value=NULL;
}
}
/**
* rasqal_rowsource_read_row:
* @rowsource: rasqal rowsource
*
* Read a query result row from the rowsource.
*
* If a row is returned, it is owned by the caller.
*
* Return value: row or NULL when no more rows are available
**/
rasqal_row*
rasqal_rowsource_read_row(rasqal_rowsource *rowsource)
{
rasqal_row* row = NULL;
if(!rowsource || rowsource->finished)
return NULL;
if(rowsource->flags & RASQAL_ROWSOURCE_FLAGS_SAVED_ROWS) {
/* return row from saved rows sequence at offset */
row = (rasqal_row*)raptor_sequence_get_at(rowsource->rows_sequence,
rowsource->offset++);
#ifdef RASQAL_DEBUG
RASQAL_DEBUG3("%s rowsource %p returned saved row: ",
rowsource->handler->name, rowsource);
if(row)
rasqal_row_print(row, stderr);
else
fputs("NONE", stderr);
fputs("\n", stderr);
#endif
if(row)
row = rasqal_new_row_from_row(row);
/* row is owned by us */
} else {
if(rasqal_rowsource_ensure_variables(rowsource))
return NULL;
if(rowsource->handler->read_row) {
row = rowsource->handler->read_row(rowsource, rowsource->user_data);
/* row is owned by us */
if(row && rowsource->flags & RASQAL_ROWSOURCE_FLAGS_SAVE_ROWS) {
if(!rowsource->rows_sequence) {
rowsource->rows_sequence = raptor_new_sequence((raptor_data_free_handler)rasqal_free_row,
(raptor_data_print_handler)rasqal_row_print);
rowsource->offset = 0;
}
/* copy to save it away */
row = rasqal_new_row_from_row(row);
raptor_sequence_push(rowsource->rows_sequence, row);
}
} else {
if(!rowsource->rows_sequence) {
raptor_sequence* seq;
seq = rasqal_rowsource_read_all_rows(rowsource);
if(rowsource->rows_sequence)
raptor_free_sequence(rowsource->rows_sequence);
/* rows_sequence now owns all rows */
rowsource->rows_sequence = seq;
rowsource->offset = 0;
}
if(rowsource->rows_sequence) {
/* return row from sequence at offset */
row = (rasqal_row*)raptor_sequence_get_at(rowsource->rows_sequence,
rowsource->offset++);
if(row)
row = rasqal_new_row_from_row(row);
/* row is owned by us */
}
}
}
if(!row) {
rowsource->finished = 1;
if(rowsource->flags & RASQAL_ROWSOURCE_FLAGS_SAVE_ROWS)
rowsource->flags |= RASQAL_ROWSOURCE_FLAGS_SAVED_ROWS;
} else {
rowsource->count++;
/* Generate a group around all rows if there are no groups returned */
if(rowsource->generate_group && row->group_id < 0)
row->group_id = 0;
}
#ifdef RASQAL_DEBUG
RASQAL_DEBUG3("%s rowsource %p returned row: ", rowsource->handler->name,
rowsource);
if(row)
rasqal_row_print(row, stderr);
else
fputs("NONE", stderr);
fputs("\n", stderr);
#endif
return row;
}
/**
* librdf_serializer_register_factory:
* @world: redland world object
* @name: the name of the serializer
* @label: the label of the serializer (optional)
* @mime_type: MIME type of the syntax (optional)
* @uri_string: URI of the syntax (optional)
* @factory: function to be called to register the factor parameters
*
* Register a serializer factory .
*
**/
REDLAND_EXTERN_C
void
librdf_serializer_register_factory(librdf_world *world,
const char *name, const char *label,
const char *mime_type,
const unsigned char *uri_string,
void (*factory) (librdf_serializer_factory*))
{
librdf_serializer_factory *serializer;
librdf_world_open(world);
#if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1
LIBRDF_DEBUG2("Received registration for serializer %s\n", name);
#endif
if(!world->serializers) {
world->serializers = raptor_new_sequence((raptor_data_free_handler)librdf_free_serializer_factory, NULL);
if(!world->serializers)
goto oom;
}
serializer=(librdf_serializer_factory*)LIBRDF_CALLOC(librdf_serializer_factory, 1,
sizeof(librdf_serializer_factory));
if(!serializer)
goto oom;
serializer->name=(char*)LIBRDF_MALLOC(cstring, strlen(name)+1);
if(!serializer->name)
goto oom_tidy;
strcpy(serializer->name, name);
if(label) {
serializer->label=(char*)LIBRDF_MALLOC(cstring, strlen(label)+1);
if(!serializer->label)
goto oom_tidy;
strcpy(serializer->label, label);
}
/* register mime type if any */
if(mime_type) {
serializer->mime_type=(char*)LIBRDF_MALLOC(cstring, strlen(mime_type)+1);
if(!serializer->mime_type)
goto oom_tidy;
strcpy(serializer->mime_type, mime_type);
}
/* register URI if any */
if(uri_string) {
serializer->type_uri=librdf_new_uri(world, uri_string);
if(!serializer->type_uri)
goto oom_tidy;
}
if(raptor_sequence_push(world->serializers, serializer))
goto oom;
/* Call the serializer registration function on the new object */
(*factory)(serializer);
#if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1
LIBRDF_DEBUG3("%s has context size %d\n", name, serializer->context_length);
#endif
return;
oom_tidy:
librdf_free_serializer_factory(serializer);
oom:
LIBRDF_FATAL1(world, LIBRDF_FROM_SERIALIZER, "Out of memory");
}
int
main(int argc, char *argv[])
{
#if 0
raptor_uri *xsd_uri;
raptor_uri *dateTime_uri;
rasqal_literal *l1, *l2;
int fn_i;
raptor_uri* fn_uri;
const unsigned char *fn_name;
rasqal_extension_fn fn;
raptor_sequence *fn_args;
char *error;
rasqal_literal *fn_result;
rasqal_world *world;
world = rasqal_new_world();
if(!world || rasqal_world_open(world)) {
fprintf(stderr, "%s: rasqal_world init failed\n", program);
return(1);
}
xsd_uri = raptor_new_uri(raptor_xmlschema_datatypes_namespace_uri);
dateTime_uri = raptor_new_uri_from_uri_local_name(xsd_uri, (const unsigned char*)"dateTime");
rasqal_init_datatypes();
fn_args = raptor_new_sequence((raptor_sequence_free_handler*)rasqal_free_literal, (raptor_sequence_print_handler*)rasqal_literal_print);
l1 = rasqal_new_string_literal((unsigned char*)strdup("2004-05-04"), NULL, raptor_uri_copy(dateTime_uri), NULL);
raptor_sequence_push(fn_args, l1);
l2 = rasqal_new_string_literal((unsigned char*)strdup("2003-01-02"), NULL, raptor_uri_copy(dateTime_uri), NULL);
raptor_sequence_push(fn_args, l2);
fn_i = 0;
fn_name = rasqal_xsd_datatype_fns[fn_i].name;
fn = rasqal_xsd_datatype_fns[fn_i].fn;
fn_uri = rasqal_xsd_datatype_fns[fn_i].uri;
error = NULL;
fn_result = fn(fn_uri, fn_args, &error);
raptor_free_sequence(fn_args);
if(!fn_result) {
if(error)
fprintf(stderr, "function %s failed with error %s\n", fn_name, error);
else
fprintf(stderr, "function %s unknown error\n", fn_name);
} else {
fprintf(stderr, "function %s returned result: ", fn_name);
rasqal_literal_print(fn_result, stderr);
fputc('\n', stderr);
}
if(fn_result)
rasqal_free_literal(fn_result);
rasqal_finish_datatypes();
raptor_free_uri(xsd_uri);
raptor_free_uri(dateTime_uri);
rasqal_free_world(world);
#endif
return 0;
}
int
main(int argc, char *argv[])
{
raptor_sequence* seq=raptor_new_sequence(NULL, (raptor_print_handler*)raptor_sequence_print_string);
char *s;
program=argv[0];
raptor_sequence_set_at(seq, 0, (void*)"first");
raptor_sequence_push(seq, (void*)"third");
raptor_sequence_shift(seq, (void*)"second");
s=(char*)raptor_sequence_get_at(seq, 0);
assert_match(raptor_sequence_get_at, s, "second");
s=(char*)raptor_sequence_get_at(seq, 1);
assert_match(raptor_sequence_get_at, s, "first");
s=(char*)raptor_sequence_get_at(seq, 2);
assert_match(raptor_sequence_get_at, s, "third");
if(raptor_sequence_size(seq) !=3)
exit(1);
fprintf(stderr, "%s: sequence after additions: ", program);
raptor_sequence_print(seq, stderr);
fputc('\n', stderr);
/* now made alphabetical i.e. first, second, third */
raptor_sequence_sort(seq, raptor_compare_strings);
fprintf(stderr, "%s: sequence after sort: ", program);
raptor_sequence_print(seq, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_pop(seq);
assert_match(raptor_sequence_get_at, s, "third");
if(raptor_sequence_size(seq) !=2)
exit(1);
fprintf(stderr, "%s: sequence after pop: ", program);
raptor_sequence_print(seq, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_unshift(seq);
assert_match(raptor_sequence_get_at, s, "first");
if(raptor_sequence_size(seq) !=1)
exit(1);
fprintf(stderr, "%s: sequence after unshift: ", program);
raptor_sequence_print(seq, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_get_at(seq, 0);
assert_match(raptor_sequence_get_at, s, "second");
raptor_free_sequence(seq);
return (0);
}
int
main(int argc, char *argv[])
{
const char *program=raptor_basename(argv[0]);
raptor_sequence* seq1=raptor_new_sequence(NULL, (raptor_sequence_print_handler*)raptor_sequence_print_string);
raptor_sequence* seq2=raptor_new_sequence(NULL, (raptor_sequence_print_handler*)raptor_sequence_print_string);
char *s;
int i;
if(raptor_sequence_pop(seq1) || raptor_sequence_unshift(seq1)) {
fprintf(stderr, "%s: should not be able to pop/unshift from an empty sequence\n", program);
exit(1);
}
raptor_sequence_set_at(seq1, 0, (void*)"first");
raptor_sequence_push(seq1, (void*)"third");
raptor_sequence_shift(seq1, (void*)"second");
s=(char*)raptor_sequence_get_at(seq1, 0);
assert_match_string(raptor_sequence_get_at, s, "second");
s=(char*)raptor_sequence_get_at(seq1, 1);
assert_match_string(raptor_sequence_get_at, s, "first");
s=(char*)raptor_sequence_get_at(seq1, 2);
assert_match_string(raptor_sequence_get_at, s, "third");
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 3);
fprintf(stderr, "%s: sequence after additions: ", program);
raptor_sequence_print(seq1, stderr);
fputc('\n', stderr);
/* now made alphabetical i.e. first, second, third */
raptor_sequence_sort(seq1, raptor_compare_strings);
fprintf(stderr, "%s: sequence after sort: ", program);
raptor_sequence_print(seq1, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_pop(seq1);
assert_match_string(raptor_sequence_get_at, s, "third");
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 2);
fprintf(stderr, "%s: sequence after pop: ", program);
raptor_sequence_print(seq1, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_unshift(seq1);
assert_match_string(raptor_sequence_get_at, s, "first");
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 1);
fprintf(stderr, "%s: sequence after unshift: ", program);
raptor_sequence_print(seq1, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_get_at(seq1, 0);
assert_match_string(raptor_sequence_get_at, s, "second");
raptor_sequence_push(seq2, (void*)"first.2");
if(raptor_sequence_join(seq2, seq1)) {
fprintf(stderr, "%s: raptor_sequence_join failed\n", program);
exit(1);
}
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 0);
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq2), 2);
raptor_free_sequence(seq1);
raptor_free_sequence(seq2);
/* test sequence growing */
seq1=raptor_new_sequence(NULL, (raptor_sequence_print_handler*)raptor_sequence_print_string);
for(i=0; i<100; i++)
if(raptor_sequence_shift(seq1, (void*)"foo")) {
fprintf(stderr, "%s: raptor_sequence_shift failed\n", program);
exit(1);
}
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 100);
for(i=0; i<100; i++)
raptor_sequence_unshift(seq1);
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 0);
raptor_free_sequence(seq1);
seq1=raptor_new_sequence(NULL, (raptor_sequence_print_handler*)raptor_sequence_print_string);
for(i=0; i<100; i++)
if(raptor_sequence_push(seq1, (void*)"foo")) {
fprintf(stderr, "%s: raptor_sequence_push failed\n", program);
exit(1);
}
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 100);
for(i=0; i<100; i++)
raptor_sequence_pop(seq1);
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 0);
raptor_free_sequence(seq1);
return (0);
}
/* create a new serializer */
static int
raptor_turtle_serialize_init(raptor_serializer* serializer, const char *name)
{
raptor_turtle_context* context = (raptor_turtle_context*)serializer->context;
raptor_uri *rdf_type_uri;
context->nstack = raptor_new_namespaces(serializer->world, 1);
if(!context->nstack)
return 1;
context->rdf_nspace = raptor_new_namespace(context->nstack,
(const unsigned char*)"rdf",
(const unsigned char*)raptor_rdf_namespace_uri,
0);
context->namespaces = raptor_new_sequence(NULL, NULL);
context->subjects =
raptor_new_avltree((raptor_data_compare_handler)raptor_abbrev_subject_compare,
(raptor_data_free_handler)raptor_free_abbrev_subject, 0);
context->blanks =
raptor_new_avltree((raptor_data_compare_handler)raptor_abbrev_subject_compare,
(raptor_data_free_handler)raptor_free_abbrev_subject, 0);
context->nodes =
raptor_new_avltree((raptor_data_compare_handler)raptor_abbrev_node_compare,
(raptor_data_free_handler)raptor_free_abbrev_node, 0);
rdf_type_uri = raptor_new_uri_for_rdf_concept(serializer->world,
(const unsigned char*)"type");
if(rdf_type_uri) {
raptor_term* uri_term;
uri_term = raptor_new_term_from_uri(serializer->world,
rdf_type_uri);
raptor_free_uri(rdf_type_uri);
context->rdf_type = raptor_new_abbrev_node(serializer->world, uri_term);
raptor_free_term(uri_term);
} else
context->rdf_type = NULL;
context->rdf_xml_literal_uri = raptor_new_uri(serializer->world, raptor_xml_literal_datatype_uri_string);
context->rdf_first_uri = raptor_new_uri(serializer->world, (const unsigned char*)"http://www.w3.org/1999/02/22-rdf-syntax-ns#first");
context->rdf_rest_uri = raptor_new_uri(serializer->world, (const unsigned char*)"http://www.w3.org/1999/02/22-rdf-syntax-ns#rest");
context->rdf_nil_uri = raptor_new_uri(serializer->world, (const unsigned char*)"http://www.w3.org/1999/02/22-rdf-syntax-ns#nil");
if(!context->rdf_nspace || !context->namespaces ||
!context->subjects || !context->blanks || !context->nodes ||
!context->rdf_xml_literal_uri || !context->rdf_first_uri ||
!context->rdf_rest_uri || !context->rdf_nil_uri || !context->rdf_type)
{
raptor_turtle_serialize_terminate(serializer);
return 1;
}
/* Note: item 0 in the list is rdf:RDF's namespace */
if(raptor_sequence_push(context->namespaces, context->rdf_nspace)) {
raptor_turtle_serialize_terminate(serializer);
return 1;
}
return 0;
}
/**
* rasqal_new_row_sequence:
* @world: world object ot use
* @vt: variables table to use to declare variables
* @row_data: row data
* @vars_count: number of variables in row
* @vars_seq_p: OUT parameter - pointer to place to store sequence of variables (or NULL)
*
* INTERNAL - Make a sequence of #rasqal_row* objects
* with variables defined into the @vt table and values in the sequence
*
* The @row_data parameter is an array of strings forming a table of
* width (vars_count * 2).
* The first row is a list of variable names at offset 0.
* The remaining rows are values where offset 0 is a literal and
* offset 1 is a URI string.
*
* The last row is indicated by an entire row of NULLs.
*
* Return value: sequence of rows or NULL on failure
*/
raptor_sequence*
rasqal_new_row_sequence(rasqal_world* world,
rasqal_variables_table* vt,
const char* const row_data[],
int vars_count,
raptor_sequence** vars_seq_p)
{
raptor_sequence *seq = NULL;
raptor_sequence *vars_seq = NULL;
int row_i;
int column_i;
int failed = 0;
#define GET_CELL(row, column, offset) \
row_data[((((row)*vars_count)+(column))<<1)+(offset)]
seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_row,
(raptor_data_print_handler)rasqal_row_print);
if(!seq)
return NULL;
if(vars_seq_p) {
vars_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_variable,
(raptor_data_print_handler)rasqal_variable_print);
if(!vars_seq) {
raptor_free_sequence(seq);
return NULL;
}
}
/* row 0 is variables */
row_i = 0;
for(column_i = 0; column_i < vars_count; column_i++) {
const char * var_name = GET_CELL(row_i, column_i, 0);
size_t var_name_len = strlen(var_name);
const unsigned char* name;
rasqal_variable* v;
name = (unsigned char*)RASQAL_MALLOC(cstring, var_name_len+1);
if(!name) {
failed = 1;
goto tidy;
}
memcpy((void*)name, var_name, var_name_len + 1);
v = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_NORMAL, name, NULL);
if(!v) {
failed = 1;
goto tidy;
}
if(vars_seq) {
v = rasqal_new_variable_from_variable(v);
raptor_sequence_push(vars_seq, v);
}
}
for(row_i = 1; 1; row_i++) {
rasqal_row* row;
int data_values_seen = 0;
/* Terminate on an entire row of NULLs */
for(column_i = 0; column_i < vars_count; column_i++) {
if(GET_CELL(row_i, column_i, 0) || GET_CELL(row_i, column_i, 1)) {
data_values_seen++;
break;
}
}
if(!data_values_seen)
break;
row = rasqal_new_row_for_size(world, vars_count);
if(!row) {
raptor_free_sequence(seq); seq = NULL;
goto tidy;
}
for(column_i = 0; column_i < vars_count; column_i++) {
rasqal_literal* l = NULL;
if(GET_CELL(row_i, column_i, 0)) {
/* string literal */
const char* str = GET_CELL(row_i, column_i, 0);
size_t str_len = strlen(str);
char *eptr = NULL;
int integer;
integer = (int)strtol((const char*)str, &eptr, 10);
if(!*eptr) {
/* is an integer */
l = rasqal_new_integer_literal(world, RASQAL_LITERAL_INTEGER,
integer);
} else {
unsigned char *val;
val = (unsigned char*)RASQAL_MALLOC(cstring, str_len+1);
if(val) {
memcpy(val, str, str_len + 1);
l = rasqal_new_string_literal_node(world, val, NULL, NULL);
} else
failed = 1;
}
} else if(GET_CELL(row_i, column_i, 1)) {
/* URI */
const unsigned char* str;
raptor_uri* u;
str = (const unsigned char*)GET_CELL(row_i, column_i, 1);
u = raptor_new_uri(world->raptor_world_ptr, str);
if(u)
l = rasqal_new_uri_literal(world, u);
else
failed = 1;
} else {
/* variable is not defined for this row */
continue;
}
if(!l) {
rasqal_free_row(row);
failed = 1;
goto tidy;
}
rasqal_row_set_value_at(row, column_i, l);
/* free our copy of literal, rasqal_row has a reference */
rasqal_free_literal(l);
}
raptor_sequence_push(seq, row);
}
tidy:
if(failed) {
if(seq) {
raptor_free_sequence(seq);
seq = NULL;
}
if(vars_seq) {
raptor_free_sequence(vars_seq);
vars_seq = NULL;
}
} else {
if(vars_seq) {
if(vars_seq_p)
*vars_seq_p = vars_seq;
else
raptor_free_sequence(vars_seq);
}
}
return seq;
}
static int update_op(struct update_context *uc)
{
fs_rid_vector *vec[4];
switch (uc->op->type) {
case RASQAL_UPDATE_TYPE_UNKNOWN:
add_message(uc, "Unknown update operation", 0);
return 1;
case RASQAL_UPDATE_TYPE_CLEAR:
fs_clear(uc, graph_arg(uc->op->graph_uri));
return 0;
case RASQAL_UPDATE_TYPE_CREATE:
return 0;
case RASQAL_UPDATE_TYPE_DROP:
fs_clear(uc, graph_arg(uc->op->graph_uri));
return 0;
case RASQAL_UPDATE_TYPE_LOAD:
fs_load(uc, graph_arg(uc->op->document_uri),
graph_arg(uc->op->graph_uri));
return 0;
#if RASQAL_VERSION >= 924
case RASQAL_UPDATE_TYPE_ADD:
fs_add(uc, graph_arg(uc->op->graph_uri),
graph_arg(uc->op->document_uri));
return 0;
case RASQAL_UPDATE_TYPE_MOVE:
fs_move(uc, graph_arg(uc->op->graph_uri),
graph_arg(uc->op->document_uri));
return 0;
case RASQAL_UPDATE_TYPE_COPY:
fs_copy(uc, graph_arg(uc->op->graph_uri),
graph_arg(uc->op->document_uri));
return 0;
#endif
case RASQAL_UPDATE_TYPE_UPDATE:
break;
}
fs_hash_freshen();
raptor_sequence *todel = NULL;
raptor_sequence *toins = NULL;
if (uc->op->delete_templates && !uc->op->where) {
int where = 0;
/* check to see if it's a DELETE WHERE { } */
for (int t=0; t<raptor_sequence_size(uc->op->delete_templates); t++) {
rasqal_triple *tr = raptor_sequence_get_at(uc->op->delete_templates, t);
if (any_vars(tr)) {
where = 1;
break;
}
}
if (where) {
fs_error(LOG_ERR, "DELETE WHERE { x } not yet supported");
add_message(uc, "DELETE WHERE { x } not yet supported, use DELETE { x } WHERE { x }", 0);
return 1;
}
}
#if RASQAL_VERSION >= 923
if (uc->op->where) {
todel = raptor_new_sequence(NULL, NULL);
toins = raptor_new_sequence(NULL, NULL);
raptor_sequence *todel_p = raptor_new_sequence(NULL, NULL);
raptor_sequence *toins_p = raptor_new_sequence(NULL, NULL);
raptor_sequence *vars = raptor_new_sequence(NULL, NULL);
fs_query *q = calloc(1, sizeof(fs_query));
uc->q = q;
q->qs = uc->qs;
q->rq = uc->rq;
q->flags = FS_BIND_DISTINCT;
#ifdef DEBUG_MERGE
q->flags |= FS_QUERY_CONSOLE_OUTPUT;
#endif
q->boolean = 1;
q->opt_level = 3;
q->soft_limit = -1;
q->segments = fsp_link_segments(uc->link);
q->link = uc->link;
q->bb[0] = fs_binding_new();
q->bt = q->bb[0];
/* hashtable to hold runtime created resources */
q->tmp_resources = g_hash_table_new_full(fs_rid_hash, fs_rid_equal, g_free, fs_free_cached_resource);
/* add column to denote join ordering */
fs_binding_create(q->bb[0], "_ord", FS_RID_NULL, 0);
if (uc->op->delete_templates) {
for (int t=0; t<raptor_sequence_size(uc->op->delete_templates); t++) {
rasqal_triple *tr = raptor_sequence_get_at(uc->op->delete_templates, t);
if (any_vars(tr)) {
fs_check_cons_slot(q, vars, tr->subject);
fs_check_cons_slot(q, vars, tr->predicate);
fs_check_cons_slot(q, vars, tr->object);
raptor_sequence_push(todel_p, tr);
} else {
raptor_sequence_push(todel, tr);
}
}
}
if (uc->op->insert_templates) {
for (int t=0; t<raptor_sequence_size(uc->op->insert_templates); t++) {
rasqal_triple *tr = raptor_sequence_get_at(uc->op->insert_templates, t);
if (any_vars(tr)) {
fs_check_cons_slot(q, vars, tr->subject);
fs_check_cons_slot(q, vars, tr->predicate);
fs_check_cons_slot(q, vars, tr->object);
raptor_sequence_push(toins_p, tr);
} else {
raptor_sequence_push(toins, tr);
}
}
}
q->num_vars = raptor_sequence_size(vars);
for (int i=0; i < q->num_vars; i++) {
rasqal_variable *v = raptor_sequence_get_at(vars, i);
fs_binding_add(q->bb[0], v, FS_RID_NULL, 1);
}
/* perform the WHERE match */
fs_query_process_pattern(q, uc->op->where, vars);
q->length = fs_binding_length(q->bb[0]);
for (int s=0; s<4; s++) {
vec[s] = fs_rid_vector_new(0);
}
for (int t=0; t<raptor_sequence_size(todel_p); t++) {
rasqal_triple *triple = raptor_sequence_get_at(todel_p, t);
for (int row=0; row < q->length; row++) {
delete_rasqal_triple(uc, vec, triple, row);
}
if (fs_rid_vector_length(vec[0]) > 1000) {
fsp_delete_quads_all(uc->link, vec);
}
}
if (fs_rid_vector_length(vec[0]) > 0) {
fsp_delete_quads_all(uc->link, vec);
}
for (int s=0; s<4; s++) {
//fs_rid_vector_print(vec[s], 0, stdout);
fs_rid_vector_free(vec[s]);
vec[s] = NULL;
}
for (int t=0; t<raptor_sequence_size(toins_p); t++) {
rasqal_triple *triple = raptor_sequence_get_at(toins_p, t);
for (int row=0; row < q->length; row++) {
insert_rasqal_triple(uc, triple, row);
}
}
/* must not free the rasqal_query */
q->rq = NULL;
fs_query_free(q);
uc->q = NULL;
} else {
todel = uc->op->delete_templates;
toins = uc->op->insert_templates;
}
#else
if (uc->op->where) {
fs_error(LOG_ERR, "DELETE/INSERT WHERE requires Rasqal 0.9.23 or newer");
add_message(uc, "DELETE/INSERT WHERE requires Rasqal 0.9.23 or newer", 0);
}
#endif
/* delete constant triples */
if (todel) {
for (int s=0; s<4; s++) {
vec[s] = fs_rid_vector_new(0);
}
for (int t=0; t<raptor_sequence_size(todel); t++) {
rasqal_triple *triple = raptor_sequence_get_at(todel, t);
if (any_vars(triple)) {
continue;
}
delete_rasqal_triple(uc, vec, triple, 0);
}
if (fs_rid_vector_length(vec[0]) > 0) {
fsp_delete_quads_all(uc->link, vec);
}
for (int s=0; s<4; s++) {
fs_rid_vector_free(vec[s]);
vec[s] = NULL;
}
}
/* insert constant triples */
if (toins) {
for (int t=0; t<raptor_sequence_size(toins); t++) {
rasqal_triple *triple = raptor_sequence_get_at(toins, t);
if (any_vars(triple)) {
continue;
}
insert_rasqal_triple(uc, triple, 0);
}
}
fs_hash_freshen();
return 0;
}
