static int
librdf_query_rasqal_init(librdf_query* query,
const char *name, librdf_uri* uri,
const unsigned char* query_string,
librdf_uri *base_uri)
{
librdf_query_rasqal_context *context=(librdf_query_rasqal_context*)query->context;
size_t len;
unsigned char *query_string_copy;
context->query = query;
context->language=context->query->factory->name;
context->rq=rasqal_new_query(query->world->rasqal_world_ptr, context->language, NULL);
if(!context->rq)
return 1;
rasqal_query_set_user_data(context->rq, query);
rasqal_world_set_log_handler(query->world->rasqal_world_ptr, query->world,
librdf_query_rasqal_log_handler);
len = strlen((const char*)query_string);
query_string_copy = LIBRDF_MALLOC(unsigned char*, len + 1);
if(!query_string_copy)
return 1;
strcpy((char*)query_string_copy, (const char*)query_string);
context->query_string=query_string_copy;
if(base_uri)
context->uri=librdf_new_uri_from_uri(base_uri);
return 0;
}
ssStatus_t parseM3_sparql_bindings(GSList** template_query_, unsigned char * query_str, sib_data_structure* p)
{
GSList* template_query =NULL;
librdf_world * world;
rasqal_query* rq;
rasqal_graph_pattern* gp;
gchar* prefix_query_str;
gchar* prefix_str;
//printf("RECEIVED SPARQL IN\n");
//printf("q: %s\n",op->req->query_str);
prefix_str= g_strdup_printf("PREFIX %s <%s> PREFIX %s <%s> PREFIX %s <%s> PREFIX %s <%s> ",rdf_c ,rdf_ex ,fn_c_2,fn_ex,rdfs_c,rdfs_ex,xsd_c , xsd_ex);
prefix_query_str=g_strdup_printf("%s %s", prefix_str, query_str);
rq = rasqal_new_query(p->sparql_preprocessing_world, "sparql",NULL);
//printf ("pre parsing\n");
if(rasqal_query_prepare(rq, prefix_query_str, NULL)) {
rasqal_free_query(rq);
rq = NULL;
*template_query_ =template_query;
g_free( prefix_str);
g_free( prefix_query_str);
rasqal_free_world(world);
return ss_GeneralError;
}
//printf ("query prepared\n");
gp = rasqal_query_get_query_graph_pattern(rq);
navigator_graph_pattern_load(gp, -1, 0, &template_query);
*template_query_ =template_query;
g_free( prefix_str);
g_free( prefix_query_str);
rasqal_free_query(rq);
return ss_StatusOK;
}
static rasqal_query*
roqet_init_query(rasqal_world *world,
const char* ql_name,
const char* ql_uri, const unsigned char* query_string,
raptor_uri* base_uri,
rasqal_feature query_feature, int query_feature_value,
const unsigned char* query_feature_string_value,
int store_results,
raptor_sequence* data_graphs)
{
rasqal_query* rq;
rq = rasqal_new_query(world, (const char*)ql_name,
(const unsigned char*)ql_uri);
if(!rq) {
fprintf(stderr, "%s: Failed to create query name %s\n",
program, ql_name);
goto tidy_query;
}
if(query_feature_value >= 0)
rasqal_query_set_feature(rq, query_feature, query_feature_value);
if(query_feature_string_value)
rasqal_query_set_feature_string(rq, query_feature,
query_feature_string_value);
#ifdef STORE_RESULTS_FLAG
if(store_results >= 0)
rasqal_query_set_store_results(rq, store_results);
#endif
if(rasqal_query_prepare(rq, query_string, base_uri)) {
size_t len = strlen((const char*)query_string);
fprintf(stderr, "%s: Parsing query '", program);
if(len > MAX_QUERY_ERROR_REPORT_LEN) {
(void)fwrite(query_string,
RASQAL_GOOD_CAST(size_t, MAX_QUERY_ERROR_REPORT_LEN),
sizeof(char), stderr);
fprintf(stderr, "...' (%d bytes) failed\n", RASQAL_BAD_CAST(int, len));
} else {
static rasqal_query*
check_query_init_query(rasqal_world *world,
const char* ql_name,
const unsigned char* query_string,
raptor_uri* base_uri,
raptor_sequence* data_graphs)
{
rasqal_query* rq;
rq = rasqal_new_query(world, (const char*)ql_name, NULL);
if(!rq) {
fprintf(stderr, "%s: Failed to create query in language %s\n",
program, ql_name);
goto tidy_query;
}
if(rasqal_query_prepare(rq, (const unsigned char*)query_string, base_uri)) {
fprintf(stderr, "%s: Parsing query failed\n", program);
rasqal_free_query(rq); rq = NULL;
goto tidy_query;
}
if(data_graphs) {
rasqal_data_graph* dg;
while((dg = (rasqal_data_graph*)raptor_sequence_pop(data_graphs))) {
if(rasqal_query_add_data_graph(rq, dg)) {
fprintf(stderr, "%s: Failed to add data graph to query\n",
program);
goto tidy_query;
}
}
}
tidy_query:
return rq;
}
int
main(int argc, char *argv[])
{
const char *program = rasqal_basename(argv[0]);
rasqal_rowsource *rowsource = NULL;
rasqal_rowsource *left_rs = NULL;
rasqal_rowsource *right_rs = NULL;
rasqal_world* world = NULL;
rasqal_query* query = NULL;
raptor_sequence* seq = NULL;
int failures = 0;
int vars_count;
rasqal_variables_table* vt;
raptor_sequence* vars_seq = NULL;
rasqal_row_compatible* rc_map = NULL;
int i;
world = rasqal_new_world(); rasqal_world_open(world);
query = rasqal_new_query(world, "sparql", NULL);
vt = query->vars_table;
/* 3 variables and 4 rows */
vars_count = 3;
seq = rasqal_new_row_sequence(world, vt, compatible_data_abc_rows, vars_count,
&vars_seq);
if(!seq) {
fprintf(stderr,
"%s: failed to create left sequence of %d vars\n", program,
vars_count);
failures++;
goto tidy;
}
left_rs = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq);
if(!left_rs) {
fprintf(stderr, "%s: failed to create left rowsource\n", program);
failures++;
goto tidy;
}
/* vars_seq and seq are now owned by left_rs */
vars_seq = seq = NULL;
/* 3 variables and 4 rows */
vars_count = 3;
seq = rasqal_new_row_sequence(world, vt, compatible_data_abcd_rows,
vars_count, &vars_seq);
if(!seq) {
fprintf(stderr,
"%s: failed to create right sequence of %d rows\n", program,
vars_count);
failures++;
goto tidy;
}
right_rs = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq);
if(!right_rs) {
fprintf(stderr, "%s: failed to create right rowsource\n", program);
failures++;
goto tidy;
}
/* vars_seq and seq are now owned by right_rs */
vars_seq = seq = NULL;
rc_map = rasqal_new_row_compatible(vt, left_rs, right_rs);
if(!rc_map) {
fprintf(stderr, "%s: failed to create row compatible\n", program);
failures++;
goto tidy;
}
rasqal_print_row_compatible(stderr, rc_map);
#ifdef RASQAL_DEBUG
fputs("\n", stderr);
#endif
for(i = 0; i < EXPECTED_ROWS_COUNT; i++) {
rasqal_row *left_row = rasqal_rowsource_read_row(left_rs);
rasqal_row *right_row = rasqal_rowsource_read_row(right_rs);
int expected = expected_compatible_results[i];
int compatible;
if(!left_row) {
fprintf(stderr, "%s: FAILED left rowsource ended early at row #%d\n", program, i);
failures++;
goto tidy;
}
if(!right_row) {
fprintf(stderr, "%s: FAILED right rowsource ended early at row #%d\n", program, i);
failures++;
goto tidy;
}
compatible = rasqal_row_compatible_check(rc_map, left_row, right_row);
RASQAL_DEBUG4("%s: compatible check for row #%d returned %d\n",
program, i, compatible);
if(compatible != expected) {
fprintf(stderr,
"%s: FAILED compatible check for row #%d returned %d expected %d\n",
program, i, compatible, expected);
failures++;
}
#ifdef RASQAL_DEBUG
fputs("\n", stderr);
#endif
if(left_row)
rasqal_free_row(left_row);
if(right_row)
rasqal_free_row(right_row);
}
tidy:
if(rc_map)
rasqal_free_row_compatible(rc_map);
if(seq)
raptor_free_sequence(seq);
if(left_rs)
rasqal_free_rowsource(left_rs);
if(right_rs)
rasqal_free_rowsource(right_rs);
if(rowsource)
rasqal_free_rowsource(rowsource);
if(query)
rasqal_free_query(query);
if(world)
rasqal_free_world(world);
return failures;
}
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_args_seq = NULL;
int failures = 0;
rasqal_variables_table* vt;
rasqal_rowsource *input_rs = NULL;
raptor_sequence* vars_seq = NULL;
raptor_sequence* exprs_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 < AGGREGATION_TESTS_COUNT; test_id++) {
int input_vars_count = test_data[test_id].input_vars;
int output_rows_count = test_data[test_id].output_rows;
int output_vars_count = test_data[test_id].output_vars;
const int* input_group_ids = test_data[test_id].group_ids;
const int* result_int_data = test_data[test_id].result_data;
const char* const* result_string_data = test_data[test_id].result_string_data;
rasqal_op op = test_data[test_id].op;
raptor_sequence* seq = NULL;
int count;
int size;
int i;
char* output_var_name;
rasqal_variable* output_var;
rasqal_expression* expr;
int output_row_size = (input_vars_count + output_vars_count);
if(output_vars_count != 1) {
fprintf(stderr,
"%s: test %d expects %d variables which is not supported. Test skipped\n",
program, test_id, output_vars_count);
failures++;
goto tidy;
}
row_seq = rasqal_new_row_sequence(world, vt, test_data[test_id].data,
test_data[test_id].input_vars, &vars_seq);
if(row_seq) {
for(i = 0; i < test_data[test_id].input_rows; i++) {
rasqal_row* row = (rasqal_row*)raptor_sequence_get_at(row_seq, i);
row->group_id = input_group_ids[i];
}
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;
}
expr_args_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_expression,
(raptor_data_print_handler)rasqal_expression_print);
if(test_data[test_id].expr_agg_vars[0] != NULL) {
int vindex;
const unsigned char* var_name;
for(vindex = 0;
(var_name = (const unsigned char*)test_data[test_id].expr_agg_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_args_seq, e);
else {
fprintf(stderr, "%s: failed to create variable %s\n", program,
(const char*)var_name);
failures++;
goto tidy;
}
}
} /* if vars */
output_var_name = (char*)RASQAL_MALLOC(cstring, 5);
memcpy(output_var_name, "fake", 5);
output_var = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_ANONYMOUS,
(const unsigned char*)output_var_name, NULL);
expr = make_test_expr(world, expr_args_seq, op);
/* expr_args_seq is now owned by expr */
expr_args_seq = NULL;
exprs_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_expression,
(raptor_data_print_handler)rasqal_expression_print);
raptor_sequence_push(exprs_seq, expr);
/* expr is now owned by exprs_seq */
expr = NULL;
vars_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_variable,
(raptor_data_print_handler)rasqal_variable_print);
output_var = rasqal_new_variable_from_variable(output_var);
raptor_sequence_push(vars_seq, output_var);
rowsource = rasqal_new_aggregation_rowsource(world, query, input_rs,
exprs_seq, vars_seq);
/* exprs_seq, vars_seq and input_rs are now owned by rowsource */
exprs_seq = NULL; vars_seq = NULL; input_rs = NULL;
if(!rowsource) {
fprintf(stderr, "%s: failed to create aggregation rowsource\n", program);
failures++;
goto tidy;
}
/* Test the rowsource */
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 aggregation rowsource\n",
program, test_id);
failures++;
goto tidy;
}
count = raptor_sequence_size(seq);
if(count != output_rows_count) {
fprintf(stderr,
"%s: test %d rasqal_rowsource_read_all_rows() returned %d rows for a aggregation rowsource, expected %d\n",
program, test_id, count, output_rows_count);
failures++;
goto tidy;
}
size = rasqal_rowsource_get_size(rowsource);
if(size != output_row_size) {
fprintf(stderr,
"%s: test %d rasqal_rowsource_get_size() returned %d columns (variables) for a aggregation rowsource, expected %d\n",
program, test_id, size, output_row_size);
failures++;
goto tidy;
}
if(result_int_data) {
for(i = 0; i < output_rows_count; i++) {
rasqal_row* row = (rasqal_row*)raptor_sequence_get_at(seq, i);
rasqal_literal* value;
int integer;
int expected_integer = result_int_data[i];
int vc;
if(row->size != output_row_size) {
fprintf(stderr,
"%s: test %d row #%d is size %d expected %d\n",
program, test_id, i, row->size, output_row_size);
failures++;
goto tidy;
}
/* Expected variable ordering in output row is:
* {input vars} {output_vars}
*/
for(vc = 0; vc < output_vars_count; vc++) {
rasqal_variable* row_var;
int offset = input_vars_count + vc;
row_var = rasqal_rowsource_get_variable_by_offset(rowsource, offset);
value = row->values[offset];
if(!value) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d result is NULL\n",
program, test_id, i, row_var->name, vc);
failures++;
goto tidy;
}
if(value->type != RASQAL_LITERAL_INTEGER) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d result is type %s expected integer\n",
program, test_id, i, row_var->name, vc,
rasqal_literal_type_label(value->type));
failures++;
goto tidy;
}
integer = rasqal_literal_as_integer(value, NULL);
if(integer != expected_integer) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d result is %d expected %d\n",
program, test_id, i, row_var->name, vc,
integer, expected_integer);
failures++;
goto tidy;
}
}
}
}
if(result_string_data) {
for(i = 0; i < output_rows_count; i++) {
rasqal_row* row = (rasqal_row*)raptor_sequence_get_at(seq, i);
rasqal_literal* value;
const unsigned char* str;
const char* expected_string = result_string_data[i];
int vc;
if(row->size != output_row_size) {
fprintf(stderr,
"%s: test %d row #%d is size %d expected %d\n",
program, test_id, i, row->size, output_row_size);
failures++;
goto tidy;
}
/* Expected variable ordering in output row is:
* {input vars} {output_vars}
*/
for(vc = 0; vc < output_vars_count; vc++) {
rasqal_variable* row_var;
int offset = input_vars_count + vc;
row_var = rasqal_rowsource_get_variable_by_offset(rowsource, offset);
value = row->values[offset];
if(!value) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d result is NULL\n",
program, test_id, i, row_var->name, vc);
failures++;
goto tidy;
}
if(value->type != RASQAL_LITERAL_STRING) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d is type %s expected integer\n",
program, test_id, i, row_var->name, vc,
rasqal_literal_type_label(value->type));
failures++;
goto tidy;
}
str = rasqal_literal_as_string(value);
if(strcmp((const char*)str, expected_string)) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d is %s expected %s\n",
program, test_id, i, row_var->name, vc,
str, expected_string);
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_args_seq)
raptor_free_sequence(expr_args_seq);
expr_args_seq = NULL;
}
tidy:
if(exprs_seq)
raptor_free_sequence(exprs_seq);
if(vars_seq)
raptor_free_sequence(vars_seq);
if(expr_args_seq)
raptor_free_sequence(expr_args_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 fs_update(fs_query_state *qs, char *update, char **message, int unsafe)
{
rasqal_query *rq = rasqal_new_query(qs->rasqal_world, "sparql11-update", NULL);
if (!rq) {
*message = g_strdup_printf("Unable to initialise update parser");
return 1;
}
struct update_context uctxt;
rasqal_world_set_log_handler(qs->rasqal_world, &uctxt, error_handler);
memset(&uctxt, 0, sizeof(uctxt));
uctxt.link = qs->link;
uctxt.segments = fsp_link_segments(qs->link);
uctxt.qs = qs;
uctxt.rq = rq;
raptor_uri *bu = raptor_new_uri(qs->raptor_world, (unsigned char *)"local:local");
rasqal_query_prepare(rq, (unsigned char *)update, bu);
if (uctxt.error) {
if (uctxt.messages) {
*message = build_update_error_message(uctxt.messages);
g_slist_free(uctxt.messages);
}
return 1;
}
if (!quad_buffer) {
quad_buffer = calloc(uctxt.segments, sizeof(struct quad_buf));
}
int ok = 1;
for (int i=0; 1; i++) {
rasqal_update_operation *op = rasqal_query_get_update_operation(rq, i);
if (!op) {
break;
}
uctxt.op = op;
uctxt.opid = i;
if (update_op(&uctxt)) {
ok = 0;
break;
}
}
fsp_res_import_commit_all(qs->link);
fsp_quad_import_commit_all(qs->link, FS_BIND_BY_SUBJECT);
rasqal_free_query(rq);
if (uctxt.messages) {
*message = build_update_error_message(uctxt.messages);
g_slist_free(uctxt.messages);
}
for (GSList *it=uctxt.freeable; it; it=it->next) {
g_free(it->data);
}
g_slist_free(uctxt.freeable);
raptor_free_uri(bu);
if (ok) {
return 0;
} else {
return 1;
}
}
int
main(int argc, char *argv[])
{
const char *program = rasqal_basename(argv[0]);
rasqal_rowsource *rowsource = NULL;
rasqal_rowsource *left_rs = NULL;
rasqal_rowsource *right_rs = NULL;
rasqal_world* world = NULL;
rasqal_query* query = NULL;
int count;
raptor_sequence* seq = NULL;
int failures = 0;
rasqal_variables_table* vt;
int size;
int expected_size = EXPECTED_COLUMNS_COUNT;
int i;
raptor_sequence* vars_seq = NULL;
int test_count;
world = rasqal_new_world(); rasqal_world_open(world);
query = rasqal_new_query(world, "sparql", NULL);
vt = query->vars_table;
for(test_count = 0; test_count < JOIN_TESTS_COUNT; test_count++) {
rasqal_join_type join_type = join_test_config[test_count].join_type;
int expected_count = join_test_config[test_count].expected;
int vars_count;
fprintf(stderr, "%s: test #%d join type %d\n", program, test_count,
RASQAL_GOOD_CAST(int, join_type));
/* 2 variables and 3 rows */
vars_count = 2;
seq = rasqal_new_row_sequence(world, vt, join_1_data_2x3_rows, vars_count,
&vars_seq);
if(!seq) {
fprintf(stderr,
"%s: failed to create left sequence of %d vars\n", program,
vars_count);
failures++;
goto tidy;
}
left_rs = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq);
if(!left_rs) {
fprintf(stderr, "%s: failed to create left rowsource\n", program);
failures++;
goto tidy;
}
/* vars_seq and seq are now owned by left_rs */
vars_seq = seq = NULL;
/* 3 variables and 2 rows */
vars_count = 3;
seq = rasqal_new_row_sequence(world, vt, join_2_data_3x2_rows, vars_count,
&vars_seq);
if(!seq) {
fprintf(stderr,
"%s: failed to create right sequence of %d rows\n", program,
vars_count);
failures++;
goto tidy;
}
right_rs = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq);
if(!right_rs) {
fprintf(stderr, "%s: failed to create right rowsource\n", program);
failures++;
goto tidy;
}
/* vars_seq and seq are now owned by right_rs */
vars_seq = seq = NULL;
rowsource = rasqal_new_join_rowsource(world, query, left_rs, right_rs,
join_type, NULL);
if(!rowsource) {
fprintf(stderr, "%s: failed to create join rowsource\n", program);
failures++;
goto tidy;
}
/* left_rs and right_rs are now owned by rowsource */
left_rs = right_rs = NULL;
seq = rasqal_rowsource_read_all_rows(rowsource);
if(!seq) {
fprintf(stderr,
"%s: read_rows returned a NULL seq for a join rowsource\n",
program);
failures++;
goto tidy;
}
count = raptor_sequence_size(seq);
if(count != expected_count) {
fprintf(stderr,
"%s: read_rows returned %d rows for a join rowsource, expected %d\n",
program, count, expected_count);
failures++;
goto tidy;
}
size = rasqal_rowsource_get_size(rowsource);
if(size != expected_size) {
fprintf(stderr,
"%s: read_rows returned %d columns (variables) for a join rowsource, expected %d\n",
program, size, expected_size);
failures++;
goto tidy;
}
for(i = 0; i < expected_size; i++) {
rasqal_variable* v;
const char* name = NULL;
const char *expected_name = join_result_vars[i];
v = rasqal_rowsource_get_variable_by_offset(rowsource, i);
if(!v) {
fprintf(stderr,
"%s: read_rows had NULL column (variable) #%d expected %s\n",
program, i, expected_name);
failures++;
goto tidy;
}
name = RASQAL_GOOD_CAST(const char*, v->name);
if(strcmp(name, expected_name)) {
fprintf(stderr,
"%s: read_rows returned column (variable) #%d %s but expected %s\n",
program, i, name, expected_name);
failures++;
goto tidy;
}
}
#ifdef RASQAL_DEBUG
rasqal_rowsource_print_row_sequence(rowsource, seq, DEBUG_FH);
#endif
raptor_free_sequence(seq); seq = NULL;
rasqal_free_rowsource(rowsource); rowsource = NULL;
/* end test_count loop */
}
tidy:
if(seq)
raptor_free_sequence(seq);
if(left_rs)
rasqal_free_rowsource(left_rs);
if(right_rs)
rasqal_free_rowsource(right_rs);
if(rowsource)
rasqal_free_rowsource(rowsource);
if(query)
rasqal_free_query(query);
if(world)
rasqal_free_world(world);
return failures;
}
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;
rasqal_row* row = NULL;
int count;
raptor_sequence* seq = NULL;
int failures = 0;
raptor_uri* service_uri;
const unsigned char* query_string;
raptor_sequence* data_graphs = NULL;
unsigned int rs_flags = 0;
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);
service_uri = raptor_new_uri(world->raptor_world_ptr,
(const unsigned char *)"http://example.org/service");
query_string = (const unsigned char*)"SELECT * WHERE { ?s ?p ?o }";
rowsource = rasqal_new_service_rowsource(world, query, service_uri,
query_string, data_graphs,
rs_flags);
if(!rowsource) {
fprintf(stderr, "%s: failed to create service rowsource\n", program);
failures++;
goto tidy;
}
row = rasqal_rowsource_read_row(rowsource);
if(!row) {
fprintf(stderr,
"%s: read_row failed to return a row for an service rowsource\n",
program);
failures++;
goto tidy;
}
if(row->size) {
fprintf(stderr,
"%s: read_row returned an non-service row size %d for a service stream\n",
program, row->size);
failures++;
goto tidy;
}
count = rasqal_rowsource_get_rows_count(rowsource);
if(count != 1) {
fprintf(stderr, "%s: read_rows returned count %d for a service stream\n",
program, count);
failures++;
goto tidy;
}
rasqal_free_rowsource(rowsource);
/* re-init rowsource */
rowsource = rasqal_new_service_rowsource(world, query, service_uri,
query_string, data_graphs,
rs_flags);
seq = rasqal_rowsource_read_all_rows(rowsource);
if(!seq) {
fprintf(stderr, "%s: read_rows returned a NULL seq for a service stream\n",
program);
failures++;
goto tidy;
}
count = raptor_sequence_size(seq);
if(count != 1) {
fprintf(stderr, "%s: read_rows returned size %d seq for a service stream\n",
program, count);
failures++;
goto tidy;
}
tidy:
if(seq)
raptor_free_sequence(seq);
if(rowsource)
rasqal_free_rowsource(rowsource);
if(query)
rasqal_free_query(query);
if(world)
rasqal_free_world(world);
return failures;
}
static rasqal_query*
roqet_init_query(rasqal_world *world,
const char* ql_name,
const char* ql_uri, const unsigned char* query_string,
raptor_uri* base_uri,
rasqal_feature query_feature, int query_feature_value,
const unsigned char* query_feature_string_value,
int store_results,
raptor_sequence* data_graphs)
{
rasqal_query* rq;
rq = rasqal_new_query(world, (const char*)ql_name,
(const unsigned char*)ql_uri);
if(!rq) {
fprintf(stderr, "%s: Failed to create query name %s\n",
program, ql_name);
goto tidy_query;
}
if(query_feature_value >= 0)
rasqal_query_set_feature(rq, query_feature, query_feature_value);
if(query_feature_string_value)
rasqal_query_set_feature_string(rq, query_feature,
query_feature_string_value);
#ifdef STORE_RESULTS_FLAG
if(store_results >= 0)
rasqal_query_set_store_results(rq, store_results);
#endif
if(data_graphs) {
rasqal_data_graph* dg;
while((dg = (rasqal_data_graph*)raptor_sequence_pop(data_graphs))) {
if(rasqal_query_add_data_graph(rq, dg)) {
fprintf(stderr, "%s: Failed to add data graph to query\n",
program);
goto tidy_query;
}
}
}
if(rasqal_query_prepare(rq, query_string, base_uri)) {
size_t len = strlen((const char*)query_string);
fprintf(stderr, "%s: Parsing query '", program);
if(len > MAX_QUERY_ERROR_REPORT_LEN) {
(void)fwrite(query_string, MAX_QUERY_ERROR_REPORT_LEN, sizeof(char),
stderr);
fprintf(stderr, "...' (%d bytes) failed\n", (int)len);
} else {
(void)fwrite(query_string, len, sizeof(char), stderr);
fputs("' failed\n", stderr);
}
rasqal_free_query(rq);
rq = NULL;
goto tidy_query;
}
tidy_query:
return rq;
}
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) {
const char *program=rasqal_basename(argv[0]);
const char *query_language_name=QUERY_LANGUAGE;
raptor_uri *base_uri;
unsigned char *uri_string;
int test_i;
limit_test* test;
int tests_failed_count=0;
int single_shot= -1;
int query_i;
rasqal_world *world;
world=rasqal_new_world();
if(!world || rasqal_world_open(world)) {
fprintf(stderr, "%s: rasqal_world init failed\n", program);
return(1);
}
if(argc < 2 || argc > 3) {
fprintf(stderr, "USAGE: %s data-filename [test number]\n", program);
return(1);
}
if(argv[2])
single_shot=atoi(argv[2]);
uri_string=raptor_uri_filename_to_uri_string("");
base_uri = raptor_new_uri(world->raptor_world_ptr, uri_string);
raptor_free_memory(uri_string);
for(query_i=0; query_i < NQUERIES; query_i++) {
const char *query_format = limit_queries[query_i];
int dynamic_limits = (strstr(query_format, "%s %s") != NULL);
for(test_i=(single_shot >=0 ? single_shot : 0);
(test=&limit_offset_tests[test_i]) && (test->expected_count >=0);
test_i++) {
int result_i;
rasqal_query *query = NULL;
rasqal_query_results *results = NULL;
const char* expected_results;
int test_ok=1;
unsigned char *data_string;
unsigned char *query_string;
size_t qs_len;
#define LIM_OFF_BUF_SIZE 20
data_string=raptor_uri_filename_to_uri_string(argv[1]);
qs_len = strlen((const char*)data_string) + strlen(query_format) + (2 * LIM_OFF_BUF_SIZE);
query_string = RASQAL_MALLOC(unsigned char*, qs_len + 1);
if(dynamic_limits) {
char lim[LIM_OFF_BUF_SIZE];
char off[LIM_OFF_BUF_SIZE];
if(test->limit >= 0)
snprintf(lim, LIM_OFF_BUF_SIZE, "LIMIT %d", test->limit);
else
*lim = '\0';
if(test->offset >= 0)
snprintf(off, LIM_OFF_BUF_SIZE, "OFFSET %d", test->offset);
else
*off = '\0';
IGNORE_FORMAT_NONLITERAL_START
snprintf((char*)query_string, qs_len, query_format, data_string, lim, off);
IGNORE_FORMAT_NONLITERAL_END
}
else {
IGNORE_FORMAT_NONLITERAL_START
snprintf((char*)query_string, qs_len, query_format, data_string);
IGNORE_FORMAT_NONLITERAL_END
}
raptor_free_memory(data_string);
query = rasqal_new_query(world, query_language_name, NULL);
if(!query) {
fprintf(stderr, "%s: creating query in language %s FAILED\n", program,
query_language_name);
return(1);
}
#if defined(RASQAL_DEBUG) && RASQAL_DEBUG > 1
fprintf(stderr,
"%s: preparing query %d test %d - %s\n", program, query_i, test_i,
query_string);
#endif
if(rasqal_query_prepare(query, query_string, base_uri)) {
fprintf(stderr, "%s: query %d test %d prepare '%s' FAILED\n", program,
query_i, test_i, query_string);
return(1);
}
if(!dynamic_limits) {
rasqal_query_set_limit(query, test->limit);
rasqal_query_set_offset(query, test->offset);
}
#if defined(RASQAL_DEBUG) && RASQAL_DEBUG > 1
fprintf(stderr, "%s: executing query %d test %d\n", program, query_i,
test_i);
#endif
results=rasqal_query_execute(query);
if(!results) {
fprintf(stderr, "%s: query %d test %d FAILED\n", program,
query_i, test_i);
return(1);
}
/* check results */
expected_results=test->expected_results[query_i];
result_i=0;
tests_failed_count=0;
while(results && !rasqal_query_results_finished(results)) {
rasqal_literal *value;
const char* str;
char expected_str[2]={0,0};
int failed=1;
if(result_i < test->expected_count)
expected_str[0]=expected_results[result_i];
value=rasqal_query_results_get_binding_value(results, 0);
if(value) {
int error=0;
str=(const char*)rasqal_literal_as_string_flags(value, 0, &error);
if(!error && str) {
size_t len=strlen(str);
if(len == 1 && str[0] == expected_str[0])
failed=0;
}
}
if(failed) {
fprintf(stderr,
"%s: query %d test %d result %d FAILED returning value '%s' expected value '%s'\n",
program, query_i, test_i, result_i, (str ? str: "NULL"),
expected_str);
test_ok=0;
}
rasqal_query_results_next(results);
result_i++;
}
if(results)
rasqal_free_query_results(results);
if(!test_ok) {
fprintf(stderr, "%s: query %d test %d limit %d offset %d FAILED\n",
program, query_i, test_i, test->limit, test->offset);
} else {
if(result_i != test->expected_count) {
fprintf(stderr,
"%s: query %d test %d limit %d offset %d FAILED returned %d results, expected %d\n",
program,
query_i, test_i, test->limit, test->offset, result_i,
test->expected_count);
test_ok=0;
}
}
if(!test_ok) {
tests_failed_count++;
} else {
#if defined(RASQAL_DEBUG) && RASQAL_DEBUG > 1
fprintf(stderr, "%s: query %d test %d OK\n", program, query_i, test_i);
#endif
}
rasqal_free_query(query);
RASQAL_FREE(char*, query_string);
if(single_shot >=0)
break;
} /* end test loop */
} /* end query loop */
int
main(int argc, char **argv) {
const char *program=rasqal_basename(argv[0]);
rasqal_query *query = NULL;
rasqal_query_results *results = NULL;
raptor_uri *base_uri;
unsigned char *data_string;
unsigned char *uri_string;
const char *query_language_name=QUERY_LANGUAGE;
const char *query_format=QUERY_FORMAT;
unsigned char *query_string;
int count;
rasqal_world *world;
const char *data_file;
world=rasqal_new_world();
if(!world || rasqal_world_open(world)) {
fprintf(stderr, "%s: rasqal_world init failed\n", program);
return(1);
}
if((data_file = getenv("RDF_DATA_FILE"))) {
/* got data from environment */
} else {
if(argc != 2) {
fprintf(stderr, "USAGE: %s data-filename\n", program);
return(1);
}
data_file = argv[1];
}
data_string = raptor_uri_filename_to_uri_string(data_file);
query_string=(unsigned char*)RASQAL_MALLOC(cstring, strlen((const char*)data_string)+strlen(query_format)+1);
sprintf((char*)query_string, query_format, data_string);
raptor_free_memory(data_string);
uri_string=raptor_uri_filename_to_uri_string("");
base_uri = raptor_new_uri(world->raptor_world_ptr, uri_string);
raptor_free_memory(uri_string);
query=rasqal_new_query(world, query_language_name, NULL);
if(!query) {
fprintf(stderr, "%s: creating query in language %s FAILED\n", program,
query_language_name);
return(1);
}
printf("%s: preparing %s query\n", program, query_language_name);
if(rasqal_query_prepare(query, query_string, base_uri)) {
fprintf(stderr, "%s: %s query prepare FAILED\n", program,
query_language_name);
return(1);
}
RASQAL_FREE(cstring, query_string);
printf("%s: executing query #1\n", program);
results=rasqal_query_execute(query);
if(!results) {
fprintf(stderr, "%s: query execution 1 FAILED\n", program);
return(1);
}
count=0;
while(results && !rasqal_query_results_finished(results)) {
int i;
for(i=0; i<rasqal_query_results_get_bindings_count(results); i++) {
const unsigned char *name=rasqal_query_results_get_binding_name(results, i);
rasqal_literal *value=rasqal_query_results_get_binding_value(results, i);
printf("result %d: variable %s=", count+1, (char*)name);
rasqal_literal_print(value, stdout);
putchar('\n');
}
rasqal_query_results_next(results);
count++;
}
if(results)
rasqal_free_query_results(results);
if(count != EXPECTED_RESULTS_COUNT) {
fprintf(stderr, "%s: query execution 1 returned %d results, expected %d\n",
program, count, EXPECTED_RESULTS_COUNT);
return(1);
}
printf("%s: executing query #2\n", program);
results = rasqal_query_execute(query);
if(!results) {
fprintf(stderr, "%s: query execution 2 FAILED\n", program);
return(1);
}
count=0;
while(results && !rasqal_query_results_finished(results)) {
int i;
for(i=0; i<rasqal_query_results_get_bindings_count(results); i++) {
const unsigned char *name=rasqal_query_results_get_binding_name(results, i);
rasqal_literal *value=rasqal_query_results_get_binding_value(results, i);
printf("result %d: variable %s=", count+1, (char*)name);
rasqal_literal_print(value, stdout);
putchar('\n');
}
rasqal_query_results_next(results);
count++;
}
if(results)
rasqal_free_query_results(results);
if(count != EXPECTED_RESULTS_COUNT) {
fprintf(stderr, "%s: query execution 2 returned %d results, expected %d\n",
program, count, EXPECTED_RESULTS_COUNT);
return(1);
}
printf("%s: executing query #3\n", program);
results = rasqal_query_execute(query);
if(!results) {
fprintf(stderr, "%s: query execution 3 FAILED\n", program);
return(1);
}
rasqal_free_query_results(results);
printf("%s: executing query #4\n", program);
results = rasqal_query_execute(query);
if(!results) {
fprintf(stderr, "%s: query execution 4 FAILED\n", program);
return(1);
}
rasqal_free_query_results(results);
rasqal_free_query(query);
raptor_free_uri(base_uri);
rasqal_free_world(world);
return 0;
}
int
main(int argc, char *argv[])
{
const char *program = rasqal_basename(argv[0]);
rasqal_rowsource *rowsource = NULL;
raptor_sequence *seq = NULL;
rasqal_world* world = NULL;
rasqal_query* query = NULL;
rasqal_row* row = NULL;
int count;
int failures = 0;
rasqal_variables_table* vt;
int rows_count;
int i;
raptor_sequence* vars_seq = NULL;
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);
/* test 1-row rowsource (2 variables) */
rows_count = 1;
#ifdef RASQAL_DEBUG
RASQAL_DEBUG2("Testing %d-row rowsource\n", rows_count);
#endif
vt = rasqal_new_variables_table(world);
/* add 2 variables to table and 1 row sequence */
seq = rasqal_new_row_sequence(world, vt, test_1_rows, 2, &vars_seq);
if(!seq) {
fprintf(stderr, "%s: failed to create sequence of %d rows\n", program,
rows_count);
failures++;
goto tidy;
}
rowsource = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq);
if(!rowsource) {
fprintf(stderr, "%s: failed to create %d-row sequence rowsource\n",
program, rows_count);
failures++;
goto tidy;
}
/* vars_seq and seq are now owned by rowsource */
vars_seq = seq = NULL;
row = rasqal_rowsource_read_row(rowsource);
if(!row) {
fprintf(stderr,
"%s: read_row returned no row for a %d-row sequence rowsource\n",
program, rows_count);
failures++;
goto tidy;
}
#ifdef RASQAL_DEBUG
RASQAL_DEBUG1("Result Row:\n ");
rasqal_row_print(row, stderr);
fputc('\n', stderr);
#endif
rasqal_free_row(row); row = NULL;
count = rasqal_rowsource_get_rows_count(rowsource);
if(count != rows_count) {
fprintf(stderr,
"%s: read_rows returned count %d instead of %d for a %d-row sequence rowsource\n",
program, count, rows_count, rows_count);
failures++;
goto tidy;
}
row = rasqal_rowsource_read_row(rowsource);
if(row) {
fprintf(stderr,
"%s: read_row returned > %d rows for a %d-row sequence rowsource\n",
program, rows_count, rows_count);
failures++;
goto tidy;
}
rasqal_free_rowsource(rowsource); rowsource = NULL;
rasqal_free_variables_table(vt); vt = NULL;
/* test 3-row rowsource */
rows_count = 3;
#ifdef RASQAL_DEBUG
RASQAL_DEBUG2("Testing %d-row rowsource\n", rows_count);
#endif
vt = rasqal_new_variables_table(world);
/* add 4 variables to table and 3 row sequence */
seq = rasqal_new_row_sequence(world, vt, test_3_rows, 4, &vars_seq);
if(!seq) {
fprintf(stderr, "%s: failed to create sequence of %d rows\n",
program, rows_count);
failures++;
goto tidy;
}
rowsource = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq);
if(!rowsource) {
fprintf(stderr, "%s: failed to create %d-row sequence rowsource\n",
program, rows_count);
failures++;
goto tidy;
}
/* vars_seq and seq are now owned by rowsource */
vars_seq = seq = NULL;
for(i = 0; i < rows_count; i++) {
row = rasqal_rowsource_read_row(rowsource);
if(!row) {
fprintf(stderr,
"%s: read_row returned no row for row %d in a %d-row sequence rowsource\n",
program, i, rows_count);
failures++;
goto tidy;
}
#ifdef RASQAL_DEBUG
RASQAL_DEBUG1("Result Row:\n ");
rasqal_row_print(row, stderr);
fputc('\n', stderr);
#endif
rasqal_free_row(row); row = NULL;
}
count = rasqal_rowsource_get_rows_count(rowsource);
if(count != rows_count) {
fprintf(stderr,
"%s: read_rows returned count %d instead of %d for a %d-row sequence rowsource\n",
program, count, rows_count, rows_count);
failures++;
goto tidy;
}
row = rasqal_rowsource_read_row(rowsource);
if(row) {
fprintf(stderr,
"%s: read_row returned >%d rows for a %d-row sequence rowsource\n",
program, rows_count, rows_count);
failures++;
goto tidy;
}
rasqal_free_rowsource(rowsource); rowsource = NULL;
rasqal_free_variables_table(vt); vt = NULL;
tidy:
if(row)
rasqal_free_row(row);
if(seq)
raptor_free_sequence(seq);
if(rowsource)
rasqal_free_rowsource(rowsource);
if(vt)
rasqal_free_variables_table(vt);
if(query)
rasqal_free_query(query);
if(world)
rasqal_free_world(world);
return failures;
}
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;
rasqal_row* row = NULL;
int count;
raptor_sequence* seq = NULL;
int failures = 0;
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);
rowsource = rasqal_new_empty_rowsource(world, query);
if(!rowsource) {
fprintf(stderr, "%s: failed to create empty rowsource\n", program);
failures++;
goto tidy;
}
row = rasqal_rowsource_read_row(rowsource);
if(!row) {
fprintf(stderr,
"%s: read_row failed to return a row for an empty rowsource\n",
program);
failures++;
goto tidy;
}
if(row->size) {
fprintf(stderr,
"%s: read_row returned an non-empty row size %d for a empty stream\n",
program, row->size);
failures++;
goto tidy;
}
count = rasqal_rowsource_get_rows_count(rowsource);
if(count != 1) {
fprintf(stderr, "%s: read_rows returned count %d for a empty stream\n",
program, count);
failures++;
goto tidy;
}
rasqal_free_row(row); row = NULL;
rasqal_free_rowsource(rowsource);
/* re-init rowsource */
rowsource = rasqal_new_empty_rowsource(world, query);
seq = rasqal_rowsource_read_all_rows(rowsource);
if(!seq) {
fprintf(stderr, "%s: read_rows returned a NULL seq for a empty stream\n",
program);
failures++;
goto tidy;
}
count = raptor_sequence_size(seq);
if(count != 1) {
fprintf(stderr, "%s: read_rows returned size %d seq for a empty stream\n",
program, count);
failures++;
goto tidy;
}
tidy:
if(row)
rasqal_free_row(row);
if(seq)
raptor_free_sequence(seq);
if(rowsource)
rasqal_free_rowsource(rowsource);
if(query)
rasqal_free_query(query);
if(world)
rasqal_free_world(world);
return failures;
}
