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; }
void rasqal_query_results_remove_query_reference(rasqal_query_results* query_results) { rasqal_query* query; RASQAL_ASSERT_OBJECT_POINTER_RETURN(query_results, rasqal_query_results); query = query_results->query; query_results->query = NULL; rasqal_free_query(query); }
static void librdf_query_rasqal_terminate(librdf_query* query) { librdf_query_rasqal_context *context=(librdf_query_rasqal_context*)query->context; if(context->rq) rasqal_free_query(context->rq); if(context->query_string) LIBRDF_FREE(char*, context->query_string); if(context->uri) librdf_free_uri(context->uri); if(context->model) librdf_free_model(context->model); }
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[]) { 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_GRAPH ")")); 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_GRAPH)) 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 = check_query_read_file_string(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", program, result_filename, strerror(errno)); rc = 1; goto tidy_setup; } switch(results_type) { case RASQAL_QUERY_RESULTS_BINDINGS: case RASQAL_QUERY_RESULTS_BOOLEAN: /* read results via rasqal query results format */ expected_results = check_query_read_results(world, raptor_world_ptr, results_type, result_iostr, result_filename, result_format_name); raptor_free_iostream(result_iostr); result_iostr = NULL; 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_GRAPH; 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; rasqal_free_dataset(ds); ds = NULL; } break; case RASQAL_QUERY_RESULTS_SYNTAX: fprintf(stderr, "%s: Reading query results format 'syntax' is not supported", program); rc = 1; goto tidy_setup; break; case RASQAL_QUERY_RESULTS_UNKNOWN: /* failure */ fprintf(stderr, "%s: Unknown query result format cannot be tested.", program); rc = 1; goto tidy_setup; break; } } /* 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); print_bindings_result_simple(expected_results, stderr, 1); fprintf(stderr, "%s: Actual bindings results:\n", program); print_bindings_result_simple(results, stderr, 1); 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); }
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; }
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; }
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; 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 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[]) { 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); }