/** * rasqal_set_triples_source_factory: * @world: rasqal_world object * @register_fn: registration function * @user_data: user data for registration * * Register a factory to generate triple sources. * * Registers the factory that returns triples sources. Note that * there is only one of these per runtime. * * The #rasqal_triples_source_factory factory method new_triples_source is * called with the user data for some query and #rasqal_triples_source. * * Return value: non-zero on failure **/ RASQAL_EXTERN_C int rasqal_set_triples_source_factory(rasqal_world* world, rasqal_triples_source_factory_register_fn register_fn, void* user_data) { int rc; int version; if(!world || !register_fn) return 1; /* for compatibility with old API that does not call this - FIXME Remove V2 */ rasqal_world_open(world); world->triples_source_factory.user_data = user_data; rc = register_fn(&world->triples_source_factory); /* Failed if the factory API version is not in the supported range */ version = world->triples_source_factory.version; if(!(version >= RASQAL_TRIPLES_SOURCE_FACTORY_MIN_VERSION && version <= RASQAL_TRIPLES_SOURCE_FACTORY_MAX_VERSION) ) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Failed to register triples source factory - API %d is not in supported range %d to %d", version, RASQAL_TRIPLES_SOURCE_FACTORY_MIN_VERSION, RASQAL_TRIPLES_SOURCE_FACTORY_MAX_VERSION); rc = 1; } return rc; }
int rasqal_query_results_format_register_factory(rasqal_world* world, const char *name, const char *label, const unsigned char* uri_string, rasqal_query_results_formatter_func writer, rasqal_query_results_formatter_func reader, rasqal_query_results_get_rowsource_func get_rowsource, const char *mime_type) { rasqal_query_results_format_factory* factory; factory = (rasqal_query_results_format_factory*)RASQAL_CALLOC(query_results_format_factory, 1, sizeof(*factory)); if(!factory) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_FATAL, NULL, "Out of memory in rasqal_query_results_format_register_factory()"); return 1; } factory->name = name; factory->label = label; factory->uri_string = uri_string; factory->writer = writer; factory->reader = reader; factory->get_rowsource = get_rowsource; factory->mime_type = mime_type; return raptor_sequence_push(world->query_results_formats, factory); }
/** * rasqal_triples_source_error_handler: * @query: query * @locator: any locator information * @message: error message * * INTERNAL - Return an error during creation of a triples source */ void rasqal_triples_source_error_handler(rasqal_query* rdf_query, raptor_locator* locator, const char* message) { rasqal_log_error_simple(rdf_query->world, RAPTOR_LOG_LEVEL_ERROR, locator, "%s", message); }
/* * rasqal_world_register_query_result_format_factory: * @world: rasqal world * @register_factory: pointer to function to call to register the factory * * INTERNAL - Register a query result format via a factory. * * All strings set in the @factory method are shared with the * #rasqal_query_result_format_factory * * Return value: new factory object or NULL on failure **/ rasqal_query_results_format_factory* rasqal_world_register_query_results_format_factory(rasqal_world* world, int (*register_factory)(rasqal_query_results_format_factory*)) { rasqal_query_results_format_factory *factory = NULL; factory = RASQAL_CALLOC(rasqal_query_results_format_factory*, 1, sizeof(*factory)); if(!factory) return NULL; factory->world = world; if(raptor_sequence_push(world->query_results_formats, factory)) return NULL; /* on error, factory is already freed by the sequence */ /* Call the factory registration function on the new object */ if(register_factory(factory)) /* factory is owned and freed by the query_results_formats sequence */ return NULL; factory->desc.flags = 0; if(factory->get_rowsource) factory->desc.flags |= RASQAL_QUERY_RESULTS_FORMAT_FLAG_READER; if(factory->write) factory->desc.flags |= RASQAL_QUERY_RESULTS_FORMAT_FLAG_WRITER; if(raptor_syntax_description_validate(&factory->desc)) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Result query result format description failed to validate\n"); goto tidy; } #if defined(RASQAL_DEBUG) && RASQAL_DEBUG > 1 RASQAL_DEBUG3("Registered query result format %s with context size %d\n", factory->desc.names[0], factory->context_length); #endif return factory; /* Clean up on failure */ tidy: rasqal_free_query_results_format_factory(factory); return NULL; }
/* * rasqal_query_language_register_factory: * @factory: pointer to function to call to register the factory * * INTERNAL - Register a query language syntax handled by a query factory * * Return value: new factory or NULL on failure **/ RASQAL_EXTERN_C rasqal_query_language_factory* rasqal_query_language_register_factory(rasqal_world *world, int (*factory) (rasqal_query_language_factory*)) { rasqal_query_language_factory *query = NULL; query = (rasqal_query_language_factory*)RASQAL_CALLOC(rasqal_query_language_factory, 1, sizeof(*query)); if(!query) goto tidy; query->world = world; if(raptor_sequence_push(world->query_languages, query)) return NULL; /* on error, query is already freed by the sequence */ /* Call the query registration function on the new object */ if(factory(query)) return NULL; /* query is owned and freed by the query_languages sequence */ if(raptor_syntax_description_validate(&query->desc)) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Query language format description failed to validate\n"); goto tidy; } #if defined(RASQAL_DEBUG) && RASQAL_DEBUG > 1 RASQAL_DEBUG3("Registered query language %s with context size %d\n", query->names[0], query->context_length); #endif return query; /* Clean up on failure */ tidy: if(query) rasqal_free_query_language_factory(query); return NULL; }
int rasqal_uri_init(rasqal_world* world) { world->rdf_namespace_uri = raptor_new_uri(world->raptor_world_ptr, raptor_rdf_namespace_uri); if(!world->rdf_namespace_uri) goto oom; world->rdf_first_uri = raptor_new_uri_from_uri_local_name(world->raptor_world_ptr, world->rdf_namespace_uri, (const unsigned char*)"first"); world->rdf_rest_uri = raptor_new_uri_from_uri_local_name(world->raptor_world_ptr, world->rdf_namespace_uri, (const unsigned char*)"rest"); world->rdf_nil_uri = raptor_new_uri_from_uri_local_name(world->raptor_world_ptr, world->rdf_namespace_uri, (const unsigned char*)"nil"); if(!world->rdf_first_uri || !world->rdf_rest_uri || !world->rdf_nil_uri) goto oom; return 0; oom: rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_FATAL, NULL, "Out of memory in rasqal_uri_init()"); return 1; }
/* * rasqal_query_results_write_json1: * @iostr: #raptor_iostream to write the query to * @results: #rasqal_query_results query results format * @base_uri: #raptor_uri base URI of the output format * * Write a JSON version of the query results format to an * iostream in a format - INTERNAL. * * If the writing succeeds, the query results will be exhausted. * * Return value: non-0 on failure **/ static int rasqal_query_results_write_json1(rasqal_query_results_formatter* formatter, raptor_iostream *iostr, rasqal_query_results* results, raptor_uri *base_uri) { rasqal_world* world = rasqal_query_results_get_world(results); rasqal_query* query = rasqal_query_results_get_query(results); int i; int row_comma; int column_comma = 0; rasqal_query_results_type type; type = rasqal_query_results_get_type(results); if(type != RASQAL_QUERY_RESULTS_BINDINGS && type != RASQAL_QUERY_RESULTS_BOOLEAN) { rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "Cannot write JSON for %s query result format", rasqal_query_results_type_label(type)); return 1; } raptor_iostream_counted_string_write("{\n", 2, iostr); /* Header */ raptor_iostream_counted_string_write(" \"head\": {\n", 12, iostr); if(rasqal_query_results_is_bindings(results)) { raptor_iostream_counted_string_write(" \"vars\": [ ", 14, iostr); for(i = 0; 1; i++) { const unsigned char *name; name = rasqal_query_results_get_binding_name(results, i); if(!name) break; /* 'x', */ if(i > 0) raptor_iostream_counted_string_write(", ", 2, iostr); raptor_iostream_write_byte('\"', iostr); raptor_iostream_string_write(name, iostr); raptor_iostream_write_byte('\"', iostr); } raptor_iostream_counted_string_write(" ]\n", 3, iostr); } /* FIXME - could add link inside 'head': */ /* End Header */ raptor_iostream_counted_string_write(" },\n", 5, iostr); /* Boolean Results */ if(rasqal_query_results_is_boolean(results)) { raptor_iostream_counted_string_write(" ", 2, iostr); rasqal_iostream_write_json_boolean(iostr, "boolean", rasqal_query_results_get_boolean(results)); goto results3done; } /* Variable Binding Results */ raptor_iostream_counted_string_write(" \"results\": {\n", 15, iostr); if(query) { raptor_iostream_counted_string_write(" ", 4, iostr); rasqal_iostream_write_json_boolean(iostr, "ordered", (rasqal_query_get_order_condition(query, 0) != NULL)); raptor_iostream_counted_string_write(",\n", 2, iostr); raptor_iostream_counted_string_write(" ", 4, iostr); rasqal_iostream_write_json_boolean(iostr, "distinct", rasqal_query_get_distinct(query)); raptor_iostream_counted_string_write(",\n", 2, iostr); } raptor_iostream_counted_string_write(" \"bindings\" : [\n", 19, iostr); row_comma = 0; while(!rasqal_query_results_finished(results)) { if(row_comma) raptor_iostream_counted_string_write(",\n", 2, iostr); /* Result row */ raptor_iostream_counted_string_write(" {\n", 8, iostr); column_comma = 0; 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 *l = rasqal_query_results_get_binding_value(results, i); if(column_comma) raptor_iostream_counted_string_write(",\n", 2, iostr); /* <binding> */ raptor_iostream_counted_string_write(" \"", 9, iostr); raptor_iostream_string_write(name, iostr); raptor_iostream_counted_string_write("\" : { ", 6, iostr); if(!l) { raptor_iostream_string_write("\"type\": \"unbound\", \"value\": null", iostr); } else { const unsigned char* str; size_t len; switch(l->type) { case RASQAL_LITERAL_URI: raptor_iostream_string_write("\"type\": \"uri\", \"value\": \"", iostr); str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->value.uri, &len)); raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte('"', iostr); break; case RASQAL_LITERAL_BLANK: raptor_iostream_string_write("\"type\": \"bnode\", \"value\": \"", iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_write_byte('"', iostr); break; case RASQAL_LITERAL_STRING: raptor_iostream_string_write("\"type\": \"literal\", \"value\": \"", iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_write_byte('"', iostr); if(l->language) { raptor_iostream_string_write(",\n \"xml:lang\" : \"", iostr); raptor_iostream_string_write(RASQAL_GOOD_CAST(const unsigned char*, l->language), iostr); raptor_iostream_write_byte('"', iostr); } if(l->datatype) { raptor_iostream_string_write(",\n \"datatype\" : \"", iostr); str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->datatype, &len)); raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte('"', iostr); } break; case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_VARIABLE: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATE: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: case RASQAL_LITERAL_UNKNOWN: default: rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Cannot turn literal type %u into XML", l->type); } } /* End Binding */ raptor_iostream_counted_string_write(" }", 2, iostr); column_comma = 1; }
/** * rasqal_query_results_get_triple: * @query_results: #rasqal_query_results query_results * * Get the current triple in the result. * * The return value is a shared #raptor_statement. * * Return value: #raptor_statement or NULL if failed or results exhausted **/ raptor_statement* rasqal_query_results_get_triple(rasqal_query_results* query_results) { rasqal_query* query; int rc; rasqal_triple *t; rasqal_literal *s, *p, *o; raptor_statement *rs = NULL; unsigned char *nodeid; int skipped; RASQAL_ASSERT_OBJECT_POINTER_RETURN_VALUE(query_results, rasqal_query_results, NULL); if(query_results->failed || query_results->finished) return NULL; if(!rasqal_query_results_is_graph(query_results)) return NULL; query = query_results->query; if(!query) return NULL; if(query->verb == RASQAL_QUERY_VERB_DESCRIBE) return NULL; /* ensure we have a row to work on */ if(rasqal_query_results_ensure_have_row_internal(query_results)) return NULL; skipped = 0; while(1) { if(skipped) { rc = rasqal_query_results_next(query_results); if(rc) { rs = NULL; break; } query_results->current_triple_result = -1; } if(query_results->current_triple_result < 0) query_results->current_triple_result = 0; t = (rasqal_triple*)raptor_sequence_get_at(query->constructs, query_results->current_triple_result); rs = &query_results->result_triple; s = rasqal_literal_as_node(t->subject); if(!s) { rasqal_log_error_simple(query_results->world, RAPTOR_LOG_LEVEL_WARN, &query->locator, "Triple with unbound subject skipped"); skipped = 1; continue; } /* raptor v2 terms are copied, not shared */ if(rs->subject) { raptor_free_term(rs->subject); rs->subject = NULL; } switch(s->type) { case RASQAL_LITERAL_URI: rs->subject = raptor_new_term_from_uri(query_results->world->raptor_world_ptr, s->value.uri); break; case RASQAL_LITERAL_BLANK: nodeid = rasqal_prefix_id(query_results->result_count, (unsigned char*)s->string); rasqal_free_literal(s); if(!nodeid) { rasqal_log_error_simple(query_results->world, RAPTOR_LOG_LEVEL_FATAL, &query->locator, "Could not prefix subject blank identifier"); return NULL; } s = rasqal_new_simple_literal(query_results->world, RASQAL_LITERAL_BLANK, nodeid); if(!s) { rasqal_log_error_simple(query_results->world, RAPTOR_LOG_LEVEL_FATAL, &query->locator, "Could not create a new subject blank literal"); return NULL; } rs->subject = raptor_new_term_from_blank(query_results->world->raptor_world_ptr, nodeid); break; case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_VARIABLE: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: /* QNames should be gone by the time expression eval happens * Everything else is removed by rasqal_literal_as_node() above. */ case RASQAL_LITERAL_STRING: /* string [literal] subjects are not RDF */ case RASQAL_LITERAL_UNKNOWN: default: /* case RASQAL_LITERAL_STRING: */ rasqal_log_error_simple(query_results->world, RAPTOR_LOG_LEVEL_WARN, &query->locator, "Triple with non-URI/blank node subject skipped"); skipped = 1; break; } if(skipped) { if(s) rasqal_free_literal(s); continue; } p = rasqal_literal_as_node(t->predicate); if(!p) { rasqal_log_error_simple(query_results->world, RAPTOR_LOG_LEVEL_WARN, &query->locator, "Triple with unbound predicate skipped"); rasqal_free_literal(s); skipped = 1; continue; } switch(p->type) { case RASQAL_LITERAL_URI: /* raptor v2 terms are copied, not shared */ if(rs->predicate) { raptor_free_term(rs->predicate); rs->predicate = NULL; } rs->predicate = raptor_new_term_from_uri(query_results->world->raptor_world_ptr, p->value.uri); break; case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_VARIABLE: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: /* QNames should be gone by the time expression eval happens * Everything else is removed by rasqal_literal_as_node() above. */ case RASQAL_LITERAL_BLANK: case RASQAL_LITERAL_STRING: /* blank node or string [literal] predicates are not RDF */ case RASQAL_LITERAL_UNKNOWN: default: rasqal_log_error_simple(query_results->world, RAPTOR_LOG_LEVEL_WARN, &query->locator, "Triple with non-URI predicate skipped"); skipped = 1; break; } if(skipped) { rasqal_free_literal(s); if(p) rasqal_free_literal(p); continue; } o = rasqal_literal_as_node(t->object); if(!o) { rasqal_log_error_simple(query_results->world, RAPTOR_LOG_LEVEL_WARN, &query->locator, "Triple with unbound object skipped"); rasqal_free_literal(s); rasqal_free_literal(p); skipped = 1; continue; } /* raptor v2 terms are copied, not shared */ if(rs->object) { raptor_free_term(rs->object); rs->object = NULL; } switch(o->type) { case RASQAL_LITERAL_URI: rs->object = raptor_new_term_from_uri(query_results->world->raptor_world_ptr, o->value.uri); break; case RASQAL_LITERAL_BLANK: nodeid = rasqal_prefix_id(query_results->result_count, (unsigned char*)o->string); rasqal_free_literal(o); if(!nodeid) { rasqal_log_error_simple(query_results->world, RAPTOR_LOG_LEVEL_FATAL, &query->locator, "Could not prefix blank identifier"); rasqal_free_literal(s); rasqal_free_literal(p); return NULL; } o = rasqal_new_simple_literal(query_results->world, RASQAL_LITERAL_BLANK, nodeid); if(!o) { rasqal_log_error_simple(query_results->world, RAPTOR_LOG_LEVEL_FATAL, &query->locator, "Could not create a new subject blank literal"); rasqal_free_literal(s); rasqal_free_literal(p); return NULL; } rs->object = raptor_new_term_from_blank(query_results->world->raptor_world_ptr, nodeid); break; case RASQAL_LITERAL_STRING: rs->object = raptor_new_term_from_literal(query_results->world->raptor_world_ptr, o->string, o->datatype, (const unsigned char*)o->language); break; case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_VARIABLE: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: /* QNames should be gone by the time expression eval happens * Everything else is removed by rasqal_literal_as_node() above. */ case RASQAL_LITERAL_UNKNOWN: default: rasqal_log_error_simple(query_results->world, RAPTOR_LOG_LEVEL_WARN, &query->locator, "Triple with unknown object skipped"); skipped = 1; break; } if(skipped) { rasqal_free_literal(s); rasqal_free_literal(p); if(o) rasqal_free_literal(o); continue; } /* dispose previous triple if any */ if(query_results->triple) { rasqal_free_triple(query_results->triple); query_results->triple = NULL; } /* for saving s, p, o for later disposal */ query_results->triple = rasqal_new_triple(s, p, o); /* got triple, return it */ break; } return rs; }
/** * rasqal_service_execute: * @svc: rasqal service * * Execute a rasqal sparql protocol service * * Return value: query results or NULL on failure */ rasqal_query_results* rasqal_service_execute(rasqal_service* svc) { rasqal_query_results* results = NULL; unsigned char* result_string = NULL; size_t result_length; raptor_iostream* read_iostr = NULL; raptor_uri* read_base_uri = NULL; rasqal_variables_table* vars_table = NULL; rasqal_query_results_formatter* read_formatter = NULL; raptor_uri* retrieval_uri = NULL; raptor_stringbuffer* uri_sb = NULL; size_t len; unsigned char* str; raptor_world* raptor_world_ptr = rasqal_world_get_raptor(svc->world); if(!svc->www) { svc->www = raptor_new_www(raptor_world_ptr); if(!svc->www) { rasqal_log_error_simple(svc->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Failed to create WWW"); goto error; } } svc->started = 0; svc->final_uri = NULL; svc->sb = raptor_new_stringbuffer(); svc->content_type = NULL; if(svc->format) raptor_www_set_http_accept(svc->www, svc->format); else raptor_www_set_http_accept(svc->www, DEFAULT_FORMAT); raptor_www_set_write_bytes_handler(svc->www, rasqal_service_write_bytes, svc); raptor_www_set_content_type_handler(svc->www, rasqal_service_content_type_handler, svc); /* Construct a URI to retrieve following SPARQL protocol HTTP * binding from concatenation of * * 1. service_uri * 2. '?' * 3. "query=" query_string * 4. "&default-graph-uri=" background graph URI if any * 5. "&named-graph-uri=" named graph URI for all named graphs * with URI-escaping of the values */ uri_sb = raptor_new_stringbuffer(); if(!uri_sb) { rasqal_log_error_simple(svc->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Failed to create stringbuffer"); goto error; } str = raptor_uri_as_counted_string(svc->service_uri, &len); raptor_stringbuffer_append_counted_string(uri_sb, str, len, 1); raptor_stringbuffer_append_counted_string(uri_sb, (const unsigned char*)"?", 1, 1); if(svc->query_string) { raptor_stringbuffer_append_counted_string(uri_sb, (const unsigned char*)"query=", 6, 1); raptor_stringbuffer_append_uri_escaped_counted_string(uri_sb, svc->query_string, svc->query_string_len, 1); } if(svc->data_graphs) { rasqal_data_graph* dg; int i; int bg_graph_count; for(i = 0, bg_graph_count = 0; (dg = (rasqal_data_graph*)raptor_sequence_get_at(svc->data_graphs, i)); i++) { unsigned char* graph_str; size_t graph_len; raptor_uri* graph_uri; if(dg->flags & RASQAL_DATA_GRAPH_BACKGROUND) { if(bg_graph_count++) { if(bg_graph_count == 2) { /* Warn once, only when the second BG is seen */ rasqal_log_error_simple(svc->world, RAPTOR_LOG_LEVEL_WARN, NULL, "Attempted to add use background graphs"); } /* always skip after first BG */ continue; } raptor_stringbuffer_append_counted_string(uri_sb, (const unsigned char*)"&default-graph-uri=", 19, 1); graph_uri = dg->uri; } else { raptor_stringbuffer_append_counted_string(uri_sb, (const unsigned char*)"&named-graph-uri=", 17, 1); graph_uri = dg->name_uri; } graph_str = raptor_uri_as_counted_string(graph_uri, &graph_len); raptor_stringbuffer_append_uri_escaped_counted_string(uri_sb, (const char*)graph_str, graph_len, 1); } } str = raptor_stringbuffer_as_string(uri_sb); retrieval_uri = raptor_new_uri(raptor_world_ptr, str); if(!retrieval_uri) { rasqal_log_error_simple(svc->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Failed to create retrieval URI %s", raptor_uri_as_string(retrieval_uri)); goto error; } raptor_free_stringbuffer(uri_sb); uri_sb = NULL; if(raptor_www_fetch(svc->www, retrieval_uri)) { rasqal_log_error_simple(svc->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Failed to fetch retrieval URI %s", raptor_uri_as_string(retrieval_uri)); goto error; } vars_table = rasqal_new_variables_table(svc->world); if(!vars_table) { rasqal_log_error_simple(svc->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Failed to create variables table"); goto error; } results = rasqal_new_query_results(svc->world, NULL, RASQAL_QUERY_RESULTS_BINDINGS, vars_table); /* (results takes a reference/copy to vars_table) */ rasqal_free_variables_table(vars_table); vars_table = NULL; if(!results) { rasqal_log_error_simple(svc->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Failed to create query results"); goto error; } result_length = raptor_stringbuffer_length(svc->sb); result_string = raptor_stringbuffer_as_string(svc->sb); read_iostr = raptor_new_iostream_from_string(raptor_world_ptr, result_string, result_length); if(!read_iostr) { rasqal_log_error_simple(svc->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Failed to create iostream from string"); rasqal_free_query_results(results); results = NULL; goto error; } read_base_uri = svc->final_uri ? svc->final_uri : svc->service_uri; read_formatter = rasqal_new_query_results_formatter(svc->world, /* format name */ NULL, svc->content_type, /* format URI */ NULL); if(!read_formatter) { rasqal_log_error_simple(svc->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Failed to create query formatter for type %s", svc->content_type); rasqal_free_query_results(results); results = NULL; goto error; } if(rasqal_query_results_formatter_read(svc->world, read_iostr, read_formatter, results, read_base_uri)) { rasqal_log_error_simple(svc->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Failed to read from query formatter"); rasqal_free_query_results(results); results = NULL; goto error; } error: if(retrieval_uri) raptor_free_uri(retrieval_uri); if(uri_sb) raptor_free_stringbuffer(uri_sb); if(read_formatter) rasqal_free_query_results_formatter(read_formatter); if(read_iostr) raptor_free_iostream(read_iostr); if(vars_table) rasqal_free_variables_table(vars_table); if(svc->final_uri) { raptor_free_uri(svc->final_uri); svc->final_uri = NULL; } if(svc->content_type) { RASQAL_FREE(cstring, svc->content_type); svc->content_type = NULL; } if(svc->sb) { raptor_free_stringbuffer(svc->sb); svc->sb = NULL; } return results; }
/** * rasqal_expression_evaluate2: * @e: The expression to evaluate. * @eval_context: expression context * @error_p: pointer to error return flag * * Evaluate a #rasqal_expression tree in the context of a * #rasqal_evaluation_context to give a #rasqal_literal result or error. * * Return value: a #rasqal_literal value or NULL (a valid value). @error_p is set to non-0 on failure. **/ rasqal_literal* rasqal_expression_evaluate2(rasqal_expression* e, rasqal_evaluation_context* eval_context, int *error_p) { rasqal_world *world; int flags; rasqal_literal* result = NULL; rasqal_literal *l1; rasqal_literal *l2; /* pack vars from different switch cases in unions to save some stack space */ union { struct { int e1; int e2; } errs; struct { int dummy_do_not_mask_e; int free_literal; } flags; int e; } errs; union { struct { int b1; int b2; } bools; int b; int i; raptor_uri *dt_uri; const unsigned char *s; unsigned char *new_s; rasqal_variable *v; rasqal_expression *e; struct { void *dummy_do_not_mask; int found; } flags; rasqal_xsd_datetime* dt; struct timeval *tv; raptor_stringbuffer* sb; } vars; RASQAL_ASSERT_OBJECT_POINTER_RETURN_VALUE(e, rasqal_expression, NULL); RASQAL_ASSERT_OBJECT_POINTER_RETURN_VALUE(eval_context, rasqal_evaluation_context, NULL); RASQAL_ASSERT_OBJECT_POINTER_RETURN_VALUE(error_p, intp, NULL); world = eval_context->world; flags = eval_context->flags; errs.e = 0; #ifdef RASQAL_DEBUG RASQAL_DEBUG2("evaluating expression %p: ", e); rasqal_expression_print(e, stderr); fprintf(stderr, "\n"); #endif switch(e->op) { case RASQAL_EXPR_AND: errs.errs.e1 = 0; l1 = rasqal_expression_evaluate2(e->arg1, eval_context, &errs.errs.e1); if(errs.errs.e1) { vars.bools.b1 = 0; } else { vars.bools.b1 = rasqal_literal_as_boolean(l1, &errs.errs.e1); rasqal_free_literal(l1); } errs.errs.e2 = 0; l1 = rasqal_expression_evaluate2(e->arg2, eval_context, &errs.errs.e2); if(errs.errs.e2) { vars.bools.b2 = 0; } else { vars.bools.b2 = rasqal_literal_as_boolean(l1, &errs.errs.e2); rasqal_free_literal(l1); } /* See http://www.w3.org/TR/2005/WD-rdf-sparql-query-20051123/#truthTable */ if(!errs.errs.e1 && !errs.errs.e2) { /* No type error, answer is A && B */ vars.b = vars.bools.b1 && vars.bools.b2; /* don't need b1,b2 anymore */ } else { if((!vars.bools.b1 && errs.errs.e2) || (errs.errs.e1 && vars.bools.b2)) /* F && E => F. E && F => F. */ vars.b = 0; else /* Otherwise E */ goto failed; } result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_OR: errs.errs.e1 = 0; l1 = rasqal_expression_evaluate2(e->arg1, eval_context, &errs.errs.e1); if(errs.errs.e1) { vars.bools.b1 = 0; } else { vars.bools.b1 = rasqal_literal_as_boolean(l1, &errs.errs.e1); rasqal_free_literal(l1); } errs.errs.e2 = 0; l1 = rasqal_expression_evaluate2(e->arg2, eval_context, &errs.errs.e2); if(errs.errs.e2) { vars.bools.b2 = 0; } else { vars.bools.b2 = rasqal_literal_as_boolean(l1, &errs.errs.e2); rasqal_free_literal(l1); } /* See http://www.w3.org/TR/2005/WD-rdf-sparql-query-20051123/#truthTable */ if(!errs.errs.e1 && !errs.errs.e2) { /* No type error, answer is A || B */ vars.b = vars.bools.b1 || vars.bools.b2; /* don't need b1,b2 anymore */ } else { if((vars.bools.b1 && errs.errs.e2) || (errs.errs.e1 && vars.bools.b2)) /* T || E => T. E || T => T */ vars.b = 1; else /* Otherwise E */ goto failed; } result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_EQ: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } /* FIXME - this should probably be checked at literal creation * time */ if(!rasqal_xsd_datatype_check(l1->type, l1->string, flags) || !rasqal_xsd_datatype_check(l2->type, l2->string, flags)) { RASQAL_DEBUG1("One of the literals was invalid\n"); goto failed; } vars.b = (rasqal_literal_equals_flags(l1, l2, flags, &errs.e) != 0); #if RASQAL_DEBUG > 1 if(errs.e) RASQAL_DEBUG1("rasqal_literal_equals_flags returned: FAILURE\n"); else RASQAL_DEBUG2("rasqal_literal_equals_flags returned: %d\n", vars.b); #endif rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_NEQ: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_not_equals_flags(l1, l2, flags, &errs.e) != 0); #if RASQAL_DEBUG > 1 if(errs.e) RASQAL_DEBUG1("rasqal_literal_not_equals_flags returned: FAILURE\n"); else RASQAL_DEBUG2("rasqal_literal_not_equals_flags returned: %d\n", vars.b); #endif rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_LT: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags, &errs.e) < 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_GT: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags, &errs.e) > 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_LE: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags, &errs.e) <= 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_GE: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags, &errs.e) >= 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_UMINUS: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; result = rasqal_literal_negate(l1, &errs.e); rasqal_free_literal(l1); if(errs.e) goto failed; break; case RASQAL_EXPR_BOUND: result = rasqal_expression_evaluate_bound(e, eval_context, error_p); break; case RASQAL_EXPR_STR: result = rasqal_expression_evaluate_str(e, eval_context, error_p); break; case RASQAL_EXPR_LANG: result = rasqal_expression_evaluate_lang(e, eval_context, error_p); break; case RASQAL_EXPR_LANGMATCHES: result = rasqal_expression_evaluate_langmatches(e, eval_context, error_p); break; case RASQAL_EXPR_DATATYPE: result = rasqal_expression_evaluate_datatype(e, eval_context, error_p); break; case RASQAL_EXPR_ISURI: case RASQAL_EXPR_ISBLANK: case RASQAL_EXPR_ISLITERAL: case RASQAL_EXPR_ISNUMERIC: result = rasqal_expression_evaluate_istype(e, eval_context, error_p); break; case RASQAL_EXPR_PLUS: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } result = rasqal_literal_add(l1, l2, &errs.e); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; break; case RASQAL_EXPR_MINUS: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } result = rasqal_literal_subtract(l1, l2, &errs.e); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; break; case RASQAL_EXPR_STAR: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } result = rasqal_literal_multiply(l1, l2, &errs.e); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; break; case RASQAL_EXPR_SLASH: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } result = rasqal_literal_divide(l1, l2, &errs.e); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; break; case RASQAL_EXPR_REM: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.i = rasqal_literal_as_integer(l2, &errs.errs.e2); /* error if divisor is zero */ if(!vars.i) errs.errs.e2 = 1; else vars.i = rasqal_literal_as_integer(l1, &errs.errs.e1) % vars.i; rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.errs.e1 || errs.errs.e2) goto failed; result = rasqal_new_integer_literal(world, RASQAL_LITERAL_INTEGER, vars.i); break; case RASQAL_EXPR_STR_EQ: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags | RASQAL_COMPARE_NOCASE, &errs.e) == 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_STR_NEQ: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags | RASQAL_COMPARE_NOCASE, &errs.e) != 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_TILDE: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; vars.i= ~ rasqal_literal_as_integer(l1, &errs.e); rasqal_free_literal(l1); if(errs.e) goto failed; result = rasqal_new_integer_literal(world, RASQAL_LITERAL_INTEGER, vars.i); break; case RASQAL_EXPR_BANG: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; vars.b = ! rasqal_literal_as_boolean(l1, &errs.e); rasqal_free_literal(l1); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_STR_MATCH: case RASQAL_EXPR_STR_NMATCH: case RASQAL_EXPR_REGEX: result = rasqal_expression_evaluate_strmatch(e, eval_context, error_p); break; case RASQAL_EXPR_LITERAL: /* flatten any literal to a value as soon as possible - this * removes variables from expressions the first time they are seen. * (FLATTEN_LITERAL) */ result = rasqal_new_literal_from_literal(rasqal_literal_value(e->literal)); break; case RASQAL_EXPR_FUNCTION: rasqal_log_warning_simple(world, RASQAL_WARNING_LEVEL_NOT_IMPLEMENTED, eval_context->locator, "No function expressions support at present. Returning false."); result = rasqal_new_boolean_literal(world, 0); break; case RASQAL_EXPR_CAST: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; result = rasqal_literal_cast(l1, e->name, flags, &errs.e); rasqal_free_literal(l1); if(errs.e) goto failed; break; case RASQAL_EXPR_ORDER_COND_ASC: case RASQAL_EXPR_ORDER_COND_DESC: case RASQAL_EXPR_GROUP_COND_ASC: case RASQAL_EXPR_GROUP_COND_DESC: result = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); break; case RASQAL_EXPR_COUNT: case RASQAL_EXPR_SUM: case RASQAL_EXPR_AVG: case RASQAL_EXPR_MIN: case RASQAL_EXPR_MAX: case RASQAL_EXPR_SAMPLE: case RASQAL_EXPR_GROUP_CONCAT: rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, eval_context->locator, "Aggregate expressions cannot be evaluated in a general scalar expression."); errs.e = 1; goto failed; break; case RASQAL_EXPR_VARSTAR: /* constants */ break; case RASQAL_EXPR_SAMETERM: result = rasqal_expression_evaluate_sameterm(e, eval_context, error_p); break; case RASQAL_EXPR_CONCAT: result = rasqal_expression_evaluate_concat(e, eval_context, error_p); break; case RASQAL_EXPR_COALESCE: result = rasqal_expression_evaluate_coalesce(e, eval_context, error_p); break; case RASQAL_EXPR_IF: result = rasqal_expression_evaluate_if(e, eval_context, error_p); break; case RASQAL_EXPR_URI: case RASQAL_EXPR_IRI: result = rasqal_expression_evaluate_uri_constructor(e, eval_context, error_p); break; case RASQAL_EXPR_STRLANG: result = rasqal_expression_evaluate_strlang(e, eval_context, error_p); break; case RASQAL_EXPR_STRDT: result = rasqal_expression_evaluate_strdt(e, eval_context, error_p); break; case RASQAL_EXPR_BNODE: result = rasqal_expression_evaluate_bnode_constructor(e, eval_context, error_p); break; case RASQAL_EXPR_IN: result = rasqal_expression_evaluate_in_set(e, eval_context, error_p); break; case RASQAL_EXPR_NOT_IN: result = rasqal_expression_evaluate_in_set(e, eval_context, error_p); break; case RASQAL_EXPR_YEAR: case RASQAL_EXPR_MONTH: case RASQAL_EXPR_DAY: case RASQAL_EXPR_HOURS: case RASQAL_EXPR_MINUTES: case RASQAL_EXPR_SECONDS: result = rasqal_expression_evaluate_datetime_part(e, eval_context, error_p); break; case RASQAL_EXPR_CURRENT_DATETIME: case RASQAL_EXPR_NOW: result = rasqal_expression_evaluate_now(e, eval_context, error_p); break; case RASQAL_EXPR_TO_UNIXTIME: result = rasqal_expression_evaluate_to_unixtime(e, eval_context, error_p); break; case RASQAL_EXPR_FROM_UNIXTIME: result = rasqal_expression_evaluate_from_unixtime(e, eval_context, error_p); break; case RASQAL_EXPR_RAND: result = rasqal_expression_evaluate_rand(e, eval_context, error_p); break; case RASQAL_EXPR_STRLEN: result = rasqal_expression_evaluate_strlen(e, eval_context, error_p); break; case RASQAL_EXPR_UCASE: case RASQAL_EXPR_LCASE: result = rasqal_expression_evaluate_set_case(e, eval_context, error_p); break; case RASQAL_EXPR_STRSTARTS: case RASQAL_EXPR_STRENDS: case RASQAL_EXPR_CONTAINS: result = rasqal_expression_evaluate_str_prefix_suffix(e, eval_context, error_p); break; case RASQAL_EXPR_TIMEZONE: result = rasqal_expression_evaluate_datetime_timezone(e, eval_context, error_p); break; case RASQAL_EXPR_TZ: result = rasqal_expression_evaluate_datetime_tz(e, eval_context, error_p); break; case RASQAL_EXPR_ENCODE_FOR_URI: result = rasqal_expression_evaluate_encode_for_uri(e, eval_context, error_p); break; case RASQAL_EXPR_SUBSTR: result = rasqal_expression_evaluate_substr(e, eval_context, error_p); break; case RASQAL_EXPR_ABS: result = rasqal_expression_evaluate_abs(e, eval_context, error_p); break; case RASQAL_EXPR_ROUND: result = rasqal_expression_evaluate_round(e, eval_context, error_p); break; case RASQAL_EXPR_CEIL: result = rasqal_expression_evaluate_ceil(e, eval_context, error_p); break; case RASQAL_EXPR_FLOOR: result = rasqal_expression_evaluate_floor(e, eval_context, error_p); break; case RASQAL_EXPR_MD5: case RASQAL_EXPR_SHA1: case RASQAL_EXPR_SHA224: case RASQAL_EXPR_SHA256: case RASQAL_EXPR_SHA384: case RASQAL_EXPR_SHA512: result = rasqal_expression_evaluate_digest(e, eval_context, error_p); break; case RASQAL_EXPR_UNKNOWN: default: RASQAL_FATAL3("Unknown operation %s (%d)", rasqal_expression_op_label(e->op), e->op); } got_result: #ifdef RASQAL_DEBUG RASQAL_DEBUG2("result of %p: ", e); rasqal_expression_print(e, stderr); fputs( ": ", stderr); if(*error_p) fputs("FAILURE",stderr); else rasqal_literal_print(result, stderr); fputc('\n', stderr); #endif return result; failed: *error_p = 1; if(result) { rasqal_free_literal(result); result = NULL; } goto got_result; }
/* * rasqal_query_results_write_sv: * @iostr: #raptor_iostream to write the query to * @results: #rasqal_query_results query results format * @base_uri: #raptor_uri base URI of the output format * @label: name of this format for errors * @sep: column sep character * * INTERNAL - Write a @sep-separated values version of the query results format to an iostream. * * If the writing succeeds, the query results will be exhausted. * * Return value: non-0 on failure **/ static int rasqal_query_results_write_sv(raptor_iostream *iostr, rasqal_query_results* results, raptor_uri *base_uri, const char* label, char sep) { rasqal_query* query = rasqal_query_results_get_query(results); int i; int count = 1; #define empty_value_str_len 0 static const char empty_value_str[empty_value_str_len+1] = ""; #define nl_str_len 1 static const char nl_str[nl_str_len+1] = "\n"; int vars_count; if(!rasqal_query_results_is_bindings(results)) { rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "Can only write %s format for variable binding results", label); return 1; } /* Header */ raptor_iostream_counted_string_write("Result", 6, iostr); for(i = 0; 1; i++) { const unsigned char *name; name = rasqal_query_results_get_binding_name(results, i); if(!name) break; raptor_iostream_write_byte(sep, iostr); raptor_iostream_string_write(name, iostr); } raptor_iostream_counted_string_write(nl_str, nl_str_len, iostr); /* Variable Binding Results */ vars_count = rasqal_query_results_get_bindings_count(results); while(!rasqal_query_results_finished(results)) { /* Result row */ raptor_iostream_decimal_write(count++, iostr); for(i = 0; i < vars_count; i++) { rasqal_literal *l = rasqal_query_results_get_binding_value(results, i); raptor_iostream_write_byte(sep, iostr); if(!l) { if(empty_value_str_len) raptor_iostream_counted_string_write(empty_value_str, empty_value_str_len, iostr); } else switch(l->type) { const unsigned char* str; size_t len; case RASQAL_LITERAL_URI: raptor_iostream_string_write("uri(", iostr); str = (const unsigned char*)raptor_uri_as_counted_string(l->value.uri, &len); raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte(')', iostr); break; case RASQAL_LITERAL_BLANK: raptor_iostream_string_write("blank(", iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_write_byte(')', iostr); break; case RASQAL_LITERAL_STRING: if(l->datatype && l->valid) { rasqal_literal_type ltype; ltype = rasqal_xsd_datatype_uri_to_type(l->world, l->datatype); if(ltype >= RASQAL_LITERAL_INTEGER && ltype <= RASQAL_LITERAL_DECIMAL) { /* write integer, float, double and decimal XSD typed * data without quotes, datatype or language */ raptor_string_ntriples_write(l->string, l->string_len, '\0', iostr); break; } } raptor_iostream_write_byte('"', iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_write_byte('"', iostr); if(l->language) { raptor_iostream_write_byte('@', iostr); raptor_iostream_string_write((const unsigned char*)l->language, iostr); } if(l->datatype) { raptor_iostream_string_write("^^uri(", iostr); str = (const unsigned char*)raptor_uri_as_counted_string(l->datatype, &len); raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte(')', iostr); } break; case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_VARIABLE: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: case RASQAL_LITERAL_UNKNOWN: default: rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "Cannot turn literal type %d into %s", l->type, label); } /* End Binding */ } /* End Result Row */ raptor_iostream_counted_string_write(nl_str, nl_str_len, iostr); rasqal_query_results_next(results); } /* end sparql */ return 0; }
/* * rasqal_query_results_write_sv: * @iostr: #raptor_iostream to write the query to * @results: #rasqal_query_results query results format * @base_uri: #raptor_uri base URI of the output format * @label: name of this format for errors * @sep: column sep character * @csv_escape: non-0 if values are written escaped with CSV rules, else turtle * @variable_prefix: char to print before a variable name or NUL * @eol_str: end of line string * @eol_str_len: length of @eol_str * * INTERNAL - Write a @sep-separated values version of the query results format to an iostream. * * If the writing succeeds, the query results will be exhausted. * * Return value: non-0 on failure **/ static int rasqal_query_results_write_sv(raptor_iostream *iostr, rasqal_query_results* results, raptor_uri *base_uri, const char* label, const char sep, int csv_escape, const char variable_prefix, const char* eol_str, size_t eol_str_len) { rasqal_query* query = rasqal_query_results_get_query(results); int i; int vars_count; if(!rasqal_query_results_is_bindings(results)) { rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "Can only write %s format for variable binding results", label); return 1; } /* Header */ for(i = 0; 1; i++) { const unsigned char *name; name = rasqal_query_results_get_binding_name(results, i); if(!name) break; if(i > 0) raptor_iostream_write_byte(sep, iostr); if(variable_prefix) raptor_iostream_write_byte(variable_prefix, iostr); raptor_iostream_string_write(name, iostr); } raptor_iostream_counted_string_write(eol_str, eol_str_len, iostr); /* Variable Binding Results */ vars_count = rasqal_query_results_get_bindings_count(results); while(!rasqal_query_results_finished(results)) { /* Result row */ for(i = 0; i < vars_count; i++) { rasqal_literal *l = rasqal_query_results_get_binding_value(results, i); if(i > 0) raptor_iostream_write_byte(sep, iostr); if(l) { const unsigned char* str; size_t len; switch(l->type) { case RASQAL_LITERAL_URI: str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->value.uri, &len)); if(csv_escape) rasqal_iostream_write_csv_string(str, len, iostr); else { raptor_iostream_write_byte('<', iostr); if(str && len > 0) raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte('>', iostr); } break; case RASQAL_LITERAL_BLANK: raptor_bnodeid_ntriples_write(l->string, l->string_len, iostr); break; case RASQAL_LITERAL_STRING: if(csv_escape) { rasqal_iostream_write_csv_string(l->string, l->string_len, iostr); } else { if(l->datatype && l->valid) { rasqal_literal_type ltype; ltype = rasqal_xsd_datatype_uri_to_type(l->world, l->datatype); if(ltype >= RASQAL_LITERAL_INTEGER && ltype <= RASQAL_LITERAL_DECIMAL) { /* write integer, float, double and decimal XSD typed * data without quotes, datatype or language */ raptor_string_ntriples_write(l->string, l->string_len, '\0', iostr); break; } } raptor_iostream_write_byte('"', iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_write_byte('"', iostr); if(l->language) { raptor_iostream_write_byte('@', iostr); raptor_iostream_string_write(RASQAL_GOOD_CAST(const unsigned char*, l->language), iostr); } if(l->datatype) { raptor_iostream_string_write("^^<", iostr); str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->datatype, &len)); raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte('>', iostr); } } break; case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_VARIABLE: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATE: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: case RASQAL_LITERAL_UNKNOWN: default: rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "Cannot turn literal type %d into %s", l->type, label); } } /* End Binding */ }
/* * rasqal_query_results_write_turtle: * @iostr: #raptor_iostream to write the query to * @results: #rasqal_query_results query results format * @base_uri: #raptor_uri base URI of the output format * * Write a Turtle version of the query results format to an * iostream in a format - INTERNAL. * * If the writing succeeds, the query results will be exhausted. * * Return value: non-0 on failure **/ static int rasqal_query_results_write_turtle(raptor_iostream *iostr, rasqal_query_results* results, raptor_uri *base_uri) { rasqal_world* world = rasqal_query_results_get_world(results); int i; int row_semicolon; int column_semicolon = 0; int size; if(!rasqal_query_results_is_bindings(results)) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Can only write Turtle format for variable binding results"); return 1; } raptor_iostream_string_write("@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .\n", iostr); raptor_iostream_string_write("@prefix rs: <http://www.w3.org/2001/sw/DataAccess/tests/result-set#> .\n", iostr); raptor_iostream_string_write("@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .\n", iostr); raptor_iostream_write_byte('\n', iostr); raptor_iostream_counted_string_write("[] rdf:type rs:ResultSet ;\n", 35, iostr); /* Variable Binding Results */ for(i = 0; 1; i++) { const unsigned char *name; name = rasqal_query_results_get_binding_name(results, i); if(!name) break; raptor_iostream_counted_string_write(" rs:resultVariable \"", 26, iostr); raptor_iostream_string_write(name, iostr); raptor_iostream_counted_string_write("\" ;\n", 4, iostr); } size = rasqal_query_results_get_bindings_count(results); row_semicolon = 0; while(!rasqal_query_results_finished(results)) { if(row_semicolon) raptor_iostream_counted_string_write(" ;\n", 3, iostr); /* Result row */ raptor_iostream_counted_string_write(" rs:solution [ ", 22, iostr); column_semicolon = 0; for(i = 0; i < size; i++) { const unsigned char *name; rasqal_literal *l; name = rasqal_query_results_get_binding_name(results, i); l = rasqal_query_results_get_binding_value(results, i); if(column_semicolon) raptor_iostream_counted_string_write("; \n ", 25, iostr); /* binding */ raptor_iostream_counted_string_write("rs:binding [ ", 16, iostr); /* only emit rs:value and rs:variable triples if there is a value */ if(l) { raptor_iostream_counted_string_write("rs:variable \"", 15, iostr); raptor_iostream_string_write(name, iostr); raptor_iostream_counted_string_write("\" ;\n rs:value ", 56, iostr); rasqal_literal_write_turtle(l, iostr); raptor_iostream_counted_string_write("\n ] ", 39, iostr); column_semicolon = 1; } } /* End Result Row */ raptor_iostream_counted_string_write("\n ]", 8, iostr); row_semicolon = 1; rasqal_query_results_next(results); } raptor_iostream_counted_string_write(" .\n", 3, iostr); return 0; }
/** * rasqal_new_triples_source: * @query: query * * INTERNAL - Create a new triples source * * Return value: a new triples source or NULL on failure */ rasqal_triples_source* rasqal_new_triples_source(rasqal_query* query) { rasqal_triples_source_factory* rtsf = &query->world->triples_source_factory; rasqal_triples_source* rts; int rc = 0; rts = (rasqal_triples_source*)RASQAL_CALLOC(rasqal_triples_source, 1, sizeof(rasqal_triples_source)); if(!rts) return NULL; rts->user_data = RASQAL_CALLOC(user_data, 1, rtsf->user_data_size); if(!rts->user_data) { RASQAL_FREE(rasqal_triples_source, rts); return NULL; } rts->query = query; if(rtsf->version >= 2 && rtsf->init_triples_source) { /* rasqal_triples_source_factory API V2 */ rc = rtsf->init_triples_source(query, rtsf->user_data, rts->user_data, rts, rasqal_triples_source_error_handler); /* if there is an error, it will have been already reported more * specifically via the error handler so no need to do it again * below in a generic form. */ goto error_tidy; } else /* rasqal_triples_source_factory API V1 */ rc = rtsf->new_triples_source(query, rtsf->user_data, rts->user_data, rts); /* Failure if the returned triples source API version is not in the * supported range */ if(!(rts->version >= RASQAL_TRIPLES_SOURCE_MIN_VERSION && rts->version <= RASQAL_TRIPLES_SOURCE_MAX_VERSION) ) { rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Failed to create triples source - API %d not in range %d to %d", rts->version, RASQAL_TRIPLES_SOURCE_MIN_VERSION, RASQAL_TRIPLES_SOURCE_MAX_VERSION); rc = 1; } if(rc) { if(rc > 0) { rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "Failed to make triples source."); } else { rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "No data to query."); } } error_tidy: if(rc) { RASQAL_FREE(user_data, rts->user_data); RASQAL_FREE(rasqal_triples_source, rts); return NULL; } return rts; }
/* * rasqal_regex_match: * @world: world * @locator: locator * @pattern: regex pattern * @regex_flags: regex flags string * @subject: input string * @subject_len: input string length * * INTERNAL - Test if a string matches a regex pattern. * * Intended to be used for executing #RASQAL_EXPR_STR_MATCH and * #RASQAL_EXPR_STR_NMATCH operations (unused: formerly RDQL) * * Return value: <0 on error, 0 for no match, >0 for match * */ int rasqal_regex_match(rasqal_world* world, raptor_locator* locator, const char* pattern, const char* regex_flags, const char* subject, size_t subject_len) { int flag_i = 0; /* regex_flags contains i */ const char *p; #ifdef RASQAL_REGEX_PCRE pcre* re; int compile_options = PCRE_UTF8; int exec_options = 0; const char *re_error = NULL; int erroffset = 0; #endif #ifdef RASQAL_REGEX_POSIX regex_t reg; int compile_options = REG_EXTENDED; int exec_options = 0; #endif int rc = 0; for(p = regex_flags; p && *p; p++) if(*p == 'i') flag_i++; #ifdef RASQAL_REGEX_PCRE if(flag_i) compile_options |= PCRE_CASELESS; re = pcre_compile(RASQAL_GOOD_CAST(const char*, pattern), compile_options, &re_error, &erroffset, NULL); if(!re) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "Regex compile of '%s' failed - %s", pattern, re_error); rc = -1; } else { rc = pcre_exec(re, NULL, /* no study */ subject, RASQAL_BAD_CAST(int, subject_len), /* PCRE API is an int */ 0 /* startoffset */, exec_options /* options */, NULL, 0 /* ovector, ovecsize - no matches wanted */ ); if(rc >= 0) rc = 1; else if(rc != PCRE_ERROR_NOMATCH) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "Regex match failed - returned code %d", rc); rc= -1; } else rc = 0; } pcre_free(re); #endif #ifdef RASQAL_REGEX_POSIX if(flag_i) compile_options |= REG_ICASE; rc = regcomp(®, RASQAL_GOOD_CAST(const char*, pattern), compile_options); if(rc) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "Regex compile of '%s' failed", pattern); rc = -1; } else { rc = regexec(®, RASQAL_GOOD_CAST(const char*, subject), 0, NULL, /* nmatch, regmatch_t pmatch[] - no matches wanted */ exec_options /* eflags */ ); if(!rc) rc = 1; else if (rc != REG_NOMATCH) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "Regex match failed - returned code %d", rc); rc = -1; } else rc = 0; } regfree(®); #endif #ifdef RASQAL_REGEX_NONE rasqal_log_warning_simple(world, RASQAL_WARNING_LEVEL_MISSING_SUPPORT, locator, "Regex support missing, cannot compare '%s' to '%s'", match_string, pattern); rc = -1; #endif return rc; }
/* * rasqal_query_results_write_sparql_xml: * @iostr: #raptor_iostream to write the query results to * @results: #rasqal_query_results query results input * @base_uri: #raptor_uri base URI of the output format * * Write the fourth version of the SPARQL XML query results format to an * iostream in a format - INTERNAL. * * If the writing succeeds, the query results will be exhausted. * * Return value: non-0 on failure **/ static int rasqal_query_results_write_sparql_xml(rasqal_query_results_formatter* formatter, raptor_iostream *iostr, rasqal_query_results* results, raptor_uri *base_uri) { int rc=1; rasqal_world* world = rasqal_query_results_get_world(results); raptor_xml_writer* xml_writer=NULL; raptor_namespace *res_ns=NULL; raptor_namespace_stack *nstack=NULL; raptor_xml_element *sparql_element=NULL; raptor_xml_element *results_element=NULL; raptor_xml_element *result_element=NULL; raptor_xml_element *element1=NULL; raptor_xml_element *binding_element=NULL; raptor_xml_element *variable_element=NULL; raptor_qname **attrs=NULL; int i; if(!rasqal_query_results_is_bindings(results) && !rasqal_query_results_is_boolean(results)) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Can only write XML format v3 for variable binding and boolean results"); return 1; } nstack = raptor_new_namespaces(world->raptor_world_ptr, 1); if(!nstack) return 1; xml_writer = raptor_new_xml_writer(world->raptor_world_ptr, nstack, iostr); if(!xml_writer) goto tidy; res_ns=raptor_new_namespace(nstack, NULL, (const unsigned char*)"http://www.w3.org/2005/sparql-results#", 0); if(!res_ns) goto tidy; sparql_element=raptor_new_xml_element_from_namespace_local_name(res_ns, (const unsigned char*)"sparql", NULL, base_uri); if(!sparql_element) goto tidy; raptor_xml_writer_start_element(xml_writer, sparql_element); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); /* <head> */ element1=raptor_new_xml_element_from_namespace_local_name(res_ns, (const unsigned char*)"head", NULL, base_uri); if(!element1) goto tidy; raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)" ", 2); raptor_xml_writer_start_element(xml_writer, element1); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); if(rasqal_query_results_is_bindings(results)) { for(i=0; 1; i++) { const unsigned char *name; name=rasqal_query_results_get_binding_name(results, i); if(!name) break; /* <variable name="x"/> */ variable_element=raptor_new_xml_element_from_namespace_local_name(res_ns, (const unsigned char*)"variable", NULL, base_uri); if(!variable_element) goto tidy; attrs=(raptor_qname **)raptor_alloc_memory(sizeof(raptor_qname*)); if(!attrs) goto tidy; attrs[0] = raptor_new_qname_from_namespace_local_name(world->raptor_world_ptr, res_ns, (const unsigned char*)"name", (const unsigned char*)name); /* attribute value */ if(!attrs[0]) { raptor_free_memory((void*)attrs); goto tidy; } raptor_xml_element_set_attributes(variable_element, attrs, 1); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)" ", 4); raptor_xml_writer_empty_element(xml_writer, variable_element); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); raptor_free_xml_element(variable_element); variable_element=NULL; } } /* FIXME - could add <link> inside <head> */ /* </head> */ raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)" ", 2); raptor_xml_writer_end_element(xml_writer, element1); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); raptor_free_xml_element(element1); element1=NULL; /* Boolean Results */ if(rasqal_query_results_is_boolean(results)) { result_element=raptor_new_xml_element_from_namespace_local_name(res_ns, (const unsigned char*)"boolean", NULL, base_uri); if(!result_element) goto tidy; raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)" ", 2); raptor_xml_writer_start_element(xml_writer, result_element); if(rasqal_query_results_get_boolean(results)) raptor_xml_writer_raw(xml_writer, RASQAL_XSD_BOOLEAN_TRUE); else raptor_xml_writer_raw(xml_writer, RASQAL_XSD_BOOLEAN_FALSE); raptor_xml_writer_end_element(xml_writer, result_element); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); goto results3done; } /* Variable Binding Results */ /* <results> */ results_element=raptor_new_xml_element_from_namespace_local_name(res_ns, (const unsigned char*)"results", NULL, base_uri); if(!results_element) goto tidy; raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)" ", 2); raptor_xml_writer_start_element(xml_writer, results_element); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); /* declare result element for later multiple use */ result_element=raptor_new_xml_element_from_namespace_local_name(res_ns, (const unsigned char*)"result", NULL, base_uri); if(!result_element) goto tidy; while(!rasqal_query_results_finished(results)) { /* <result> */ raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)" ", 4); raptor_xml_writer_start_element(xml_writer, result_element); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); 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 *l=rasqal_query_results_get_binding_value(results, i); /* <binding> */ binding_element=raptor_new_xml_element_from_namespace_local_name(res_ns, (const unsigned char*)"binding", NULL, base_uri); if(!binding_element) goto tidy; attrs=(raptor_qname **)raptor_alloc_memory(sizeof(raptor_qname*)); if(!attrs) goto tidy; attrs[0] = raptor_new_qname_from_namespace_local_name(world->raptor_world_ptr, res_ns, (const unsigned char*)"name", name); if(!attrs[0]) { raptor_free_memory((void*)attrs); goto tidy; } raptor_xml_element_set_attributes(binding_element, attrs, 1); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)" ", 6); raptor_xml_writer_start_element(xml_writer, binding_element); if(!l) { element1=raptor_new_xml_element_from_namespace_local_name(res_ns, (const unsigned char*)"unbound", NULL, base_uri); if(!element1) goto tidy; raptor_xml_writer_empty_element(xml_writer, element1); } else switch(l->type) { case RASQAL_LITERAL_URI: element1=raptor_new_xml_element_from_namespace_local_name(res_ns, (const unsigned char*)"uri", NULL, base_uri); if(!element1) goto tidy; raptor_xml_writer_start_element(xml_writer, element1); raptor_xml_writer_cdata(xml_writer, (const unsigned char*)raptor_uri_as_string(l->value.uri)); raptor_xml_writer_end_element(xml_writer, element1); break; case RASQAL_LITERAL_BLANK: element1=raptor_new_xml_element_from_namespace_local_name(res_ns, (const unsigned char*)"bnode", NULL, base_uri); if(!element1) goto tidy; raptor_xml_writer_start_element(xml_writer, element1); raptor_xml_writer_cdata(xml_writer, (const unsigned char*)l->string); raptor_xml_writer_end_element(xml_writer, element1); break; case RASQAL_LITERAL_STRING: case RASQAL_LITERAL_UDT: element1=raptor_new_xml_element_from_namespace_local_name(res_ns, (const unsigned char*)"literal", NULL, base_uri); if(!element1) goto tidy; if(l->language || l->datatype) { attrs=(raptor_qname **)raptor_alloc_memory(sizeof(raptor_qname*)); if(!attrs) goto tidy; if(l->language) attrs[0]=raptor_new_qname(nstack, (const unsigned char*)"xml:lang", (const unsigned char*)l->language); else attrs[0] = raptor_new_qname_from_namespace_local_name(world->raptor_world_ptr, res_ns, (const unsigned char*)"datatype", (const unsigned char*)raptor_uri_as_string(l->datatype)); if(!attrs[0]) { raptor_free_memory((void*)attrs); goto tidy; } raptor_xml_element_set_attributes(element1, attrs, 1); } raptor_xml_writer_start_element(xml_writer, element1); raptor_xml_writer_cdata_counted(xml_writer, (const unsigned char*)l->string, l->string_len); raptor_xml_writer_end_element(xml_writer, element1); break; case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_VARIABLE: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_INTEGER_SUBTYPE: case RASQAL_LITERAL_UNKNOWN: default: rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Cannot turn literal type %d into XML", l->type); goto tidy; } if(element1) { raptor_free_xml_element(element1); element1=NULL; } /* </binding> */ raptor_xml_writer_end_element(xml_writer, binding_element); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); raptor_free_xml_element(binding_element); binding_element=NULL; } raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)" ", 4); raptor_xml_writer_end_element(xml_writer, result_element); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); rasqal_query_results_next(results); } raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)" ", 2); raptor_xml_writer_end_element(xml_writer, results_element); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); results3done: rc=0; raptor_xml_writer_end_element(xml_writer, sparql_element); raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); tidy: if(element1) raptor_free_xml_element(element1); if(variable_element) raptor_free_xml_element(variable_element); if(binding_element) raptor_free_xml_element(binding_element); if(result_element) raptor_free_xml_element(result_element); if(results_element) raptor_free_xml_element(results_element); if(sparql_element) raptor_free_xml_element(sparql_element); if(res_ns) raptor_free_namespace(res_ns); if(xml_writer) raptor_free_xml_writer(xml_writer); if(nstack) raptor_free_namespaces(nstack); return rc; }
/* * rasqal_query_results_write_sparql_xml: * @iostr: #raptor_iostream to write the query results to * @results: #rasqal_query_results query results input * @base_uri: #raptor_uri base URI of the output format * * Write the fourth version of the SPARQL XML query results format to an * iostream in a format - INTERNAL. * * If the writing succeeds, the query results will be exhausted. * * Return value: non-0 on failure **/ static int rasqal_query_results_write_sparql_xml(rasqal_query_results_formatter* formatter, raptor_iostream *iostr, rasqal_query_results* results, raptor_uri *base_uri) { int rc=1; rasqal_world* world = rasqal_query_results_get_world(results); raptor_xml_writer* xml_writer=NULL; raptor_namespace *res_ns=NULL; raptor_namespace_stack *nstack=NULL; raptor_xml_element *sparql_element=NULL; raptor_xml_element *results_element=NULL; raptor_xml_element *result_element=NULL; raptor_xml_element *element1=NULL; raptor_xml_element *binding_element=NULL; raptor_xml_element *variable_element=NULL; raptor_qname **attrs=NULL; int i; rasqal_query_results_type type; type = rasqal_query_results_get_type(results); if(type != RASQAL_QUERY_RESULTS_BINDINGS && type != RASQAL_QUERY_RESULTS_BOOLEAN) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Cannot write XML format v3 for %s query result format", rasqal_query_results_type_label(type)); return 1; } nstack = raptor_new_namespaces(world->raptor_world_ptr, 1); if(!nstack) return 1; xml_writer = raptor_new_xml_writer(world->raptor_world_ptr, nstack, iostr); if(!xml_writer) goto tidy; res_ns=raptor_new_namespace(nstack, NULL, RASQAL_GOOD_CAST(const unsigned char*, "http://www.w3.org/2005/sparql-results#"), 0); if(!res_ns) goto tidy; sparql_element=raptor_new_xml_element_from_namespace_local_name(res_ns, RASQAL_GOOD_CAST(const unsigned char*, "sparql"), NULL, base_uri); if(!sparql_element) goto tidy; raptor_xml_writer_start_element(xml_writer, sparql_element); raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, "\n"), 1); /* <head> */ element1=raptor_new_xml_element_from_namespace_local_name(res_ns, RASQAL_GOOD_CAST(const unsigned char*, "head"), NULL, base_uri); if(!element1) goto tidy; raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, " "), 2); raptor_xml_writer_start_element(xml_writer, element1); raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, "\n"), 1); if(rasqal_query_results_is_bindings(results)) { for(i=0; 1; i++) { const unsigned char *name; name=rasqal_query_results_get_binding_name(results, i); if(!name) break; /* <variable name="x"/> */ variable_element=raptor_new_xml_element_from_namespace_local_name(res_ns, RASQAL_GOOD_CAST(const unsigned char*,"variable"), NULL, base_uri); if(!variable_element) goto tidy; attrs=(raptor_qname **)raptor_alloc_memory(sizeof(raptor_qname*)); if(!attrs) goto tidy; attrs[0] = raptor_new_qname_from_namespace_local_name(world->raptor_world_ptr, res_ns, RASQAL_GOOD_CAST(const unsigned char*,"name"), RASQAL_GOOD_CAST(const unsigned char*, name)); /* attribute value */ if(!attrs[0]) { raptor_free_memory((void*)attrs); goto tidy; } raptor_xml_element_set_attributes(variable_element, attrs, 1); raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, " "), 4); raptor_xml_writer_empty_element(xml_writer, variable_element); raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, "\n"), 1); raptor_free_xml_element(variable_element); variable_element=NULL; } } /* FIXME - could add <link> inside <head> */ /* </head> */ raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, " "), 2); raptor_xml_writer_end_element(xml_writer, element1); raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, "\n"), 1); raptor_free_xml_element(element1); element1=NULL; /* Boolean Results */ if(rasqal_query_results_is_boolean(results)) { result_element=raptor_new_xml_element_from_namespace_local_name(res_ns, RASQAL_GOOD_CAST(const unsigned char*, "boolean"), NULL, base_uri); if(!result_element) goto tidy; raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, " "), 2); raptor_xml_writer_start_element(xml_writer, result_element); if(rasqal_query_results_get_boolean(results)) raptor_xml_writer_raw(xml_writer, RASQAL_XSD_BOOLEAN_TRUE); else raptor_xml_writer_raw(xml_writer, RASQAL_XSD_BOOLEAN_FALSE); raptor_xml_writer_end_element(xml_writer, result_element); raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, "\n"), 1); goto results3done; } /* Variable Binding Results */ /* <results> */ results_element=raptor_new_xml_element_from_namespace_local_name(res_ns, RASQAL_GOOD_CAST(const unsigned char*, "results"), NULL, base_uri); if(!results_element) goto tidy; raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, " "), 2); raptor_xml_writer_start_element(xml_writer, results_element); raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, "\n"), 1); /* declare result element for later multiple use */ result_element=raptor_new_xml_element_from_namespace_local_name(res_ns, RASQAL_GOOD_CAST(const unsigned char*, "result"), NULL, base_uri); if(!result_element) goto tidy; while(!rasqal_query_results_finished(results)) { /* <result> */ raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, " "), 4); raptor_xml_writer_start_element(xml_writer, result_element); raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, "\n"), 1); 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 *l=rasqal_query_results_get_binding_value(results, i); /* <binding> */ binding_element=raptor_new_xml_element_from_namespace_local_name(res_ns, RASQAL_GOOD_CAST(const unsigned char*, "binding"), NULL, base_uri); if(!binding_element) goto tidy; attrs=(raptor_qname **)raptor_alloc_memory(sizeof(raptor_qname*)); if(!attrs) goto tidy; attrs[0] = raptor_new_qname_from_namespace_local_name(world->raptor_world_ptr, res_ns, RASQAL_GOOD_CAST(const unsigned char*, "name"), name); if(!attrs[0]) { raptor_free_memory((void*)attrs); goto tidy; } raptor_xml_element_set_attributes(binding_element, attrs, 1); raptor_xml_writer_raw_counted(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, " "), 6); raptor_xml_writer_start_element(xml_writer, binding_element); if(!l) { element1=raptor_new_xml_element_from_namespace_local_name(res_ns, RASQAL_GOOD_CAST(const unsigned char*, "unbound"), NULL, base_uri); if(!element1) goto tidy; raptor_xml_writer_empty_element(xml_writer, element1); } else switch(l->type) { case RASQAL_LITERAL_URI: element1=raptor_new_xml_element_from_namespace_local_name(res_ns, RASQAL_GOOD_CAST(const unsigned char*, "uri"), NULL, base_uri); if(!element1) goto tidy; raptor_xml_writer_start_element(xml_writer, element1); raptor_xml_writer_cdata(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_string(l->value.uri))); raptor_xml_writer_end_element(xml_writer, element1); break; case RASQAL_LITERAL_BLANK: element1=raptor_new_xml_element_from_namespace_local_name(res_ns, RASQAL_GOOD_CAST(const unsigned char*, "bnode"), NULL, base_uri); if(!element1) goto tidy; raptor_xml_writer_start_element(xml_writer, element1); raptor_xml_writer_cdata(xml_writer, RASQAL_GOOD_CAST(const unsigned char*, l->string)); raptor_xml_writer_end_element(xml_writer, element1); break; case RASQAL_LITERAL_STRING: case RASQAL_LITERAL_UDT: element1=raptor_new_xml_element_from_namespace_local_name(res_ns, RASQAL_GOOD_CAST(const unsigned char*, "literal"), NULL, base_uri); if(!element1) goto tidy; if(l->language || l->datatype) { attrs=(raptor_qname **)raptor_alloc_memory(sizeof(raptor_qname*)); if(!attrs) goto tidy; if(l->language) attrs[0]=raptor_new_qname(nstack, RASQAL_GOOD_CAST(const unsigned char*, "xml:lang"), RASQAL_GOOD_CAST(const unsigned char*, l->language)); else attrs[0] = raptor_new_qname_from_namespace_local_name(world->raptor_world_ptr, res_ns, RASQAL_GOOD_CAST(const unsigned char*, "datatype"), RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_string(l->datatype))); if(!attrs[0]) { raptor_free_memory((void*)attrs); goto tidy; } raptor_xml_element_set_attributes(element1, attrs, 1); }
/* * rasqal_ntriples_parse_term_internal: * @world: rasqal world * @locator: locator object (in/out) (or NULL) * @start: pointer to starting character of string (in) * @dest: destination of string (in) * @lenp: pointer to length of string (in/out) * @dest_lenp: pointer to length of destination string (out) * @end_char: string ending character * @class: string class * * INTERNAL - Parse an N-Triples term with escapes. * * Relies that @dest is long enough; it need only be as large as the * input string @start since when UTF-8 encoding, the escapes are * removed and the result is always less than or equal to length of * input. * * N-Triples strings / URIs are written in ASCII at present; * characters outside the printable ASCII range are discarded with a * warning. See the grammar for full details of the allowed ranges. * * UTF-8 and the \u and \U esapes are both allowed. * * Return value: Non 0 on failure **/ static int rasqal_ntriples_parse_term_internal(rasqal_world* world, raptor_locator* locator, const unsigned char **start, unsigned char *dest, size_t *lenp, size_t *dest_lenp, char end_char, rasqal_ntriples_term_class term_class) { const unsigned char *p = *start; unsigned char c = '\0'; size_t ulen = 0; unsigned long unichar = 0; unsigned int position = 0; int end_char_seen = 0; /* find end of string, fixing backslashed characters on the way */ while(*lenp > 0) { int unichar_width; c = *p; p++; (*lenp)--; if(locator) { locator->column++; locator->byte++; } if(c > 0x7f) { /* just copy the UTF-8 bytes through */ int unichar_len; unichar_len = raptor_unicode_utf8_string_get_char(p - 1, 1 + *lenp, NULL); if(unichar_len < 0 || RASQAL_GOOD_CAST(size_t, unichar_len) > *lenp) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "UTF-8 encoding error at character %d (0x%02X) found.", c, c); /* UTF-8 encoding had an error or ended in the middle of a string */ return 1; } memmove(dest, p-1, unichar_len); dest += unichar_len; unichar_len--; /* p, *lenp were moved on by 1 earlier */ p += unichar_len; (*lenp) -= unichar_len; if(locator) { locator->column += unichar_len; locator->byte += unichar_len; } continue; } if(c != '\\') { /* finish at non-backslashed end_char */ if(end_char && c == end_char) { end_char_seen = 1; break; } if(!rasqal_ntriples_term_valid(c, position, term_class)) { if(end_char) { /* end char was expected, so finding an invalid thing is an error */ rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "Missing terminating '%c' (found '%c')", end_char, c); return 0; } else { /* it's the end - so rewind 1 to save next char */ p--; (*lenp)++; if(locator) { locator->column--; locator->byte--; } if(term_class == RASQAL_TERM_CLASS_BNODEID && dest[-1] == '.') { /* If bnode id ended on '.' move back one */ dest--; p--; (*lenp)++; if(locator) { locator->column--; locator->byte--; } } break; } } /* otherwise store and move on */ *dest++ = c; position++; continue; } if(!*lenp) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "\\ at end of input."); return 0; } c = *p; p++; (*lenp)--; if(locator) { locator->column++; locator->byte++; } switch(c) { case '"': case '\\': *dest++ = c; break; case 'b': *dest++ = '\b'; break; case 'f': *dest++ = '\f'; break; case 'n': *dest++ = '\n'; break; case 'r': *dest++ = '\r'; break; case 't': *dest++ = '\t'; break; case '<': case '>': case '{': case '}': case '|': case '^': case '`': /* Turtle 2013 allows these in URIs (as well as \" and \\) */ *dest++ = c; break; case 'u': case 'U': ulen = (c == 'u') ? 4 : 8; if(*lenp < ulen) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "%c over end of input.", c); return 0; } if(1) { unsigned int ii; int n = 0; for(ii = 0; ii < ulen; ii++) { char cc = p[ii]; if(!isxdigit(RASQAL_GOOD_CAST(char, cc))) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "N-Triples string error - illegal hex digit %c in Unicode escape '%c%s...'", cc, c, p); n = 1; break; } } if(n) break; n = sscanf((const char*)p, ((ulen == 4) ? "%04lx" : "%08lx"), &unichar); if(n != 1) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "Illegal Uncode escape '%c%s...'", c, p); break; } } p += ulen; (*lenp) -= ulen; if(locator) { locator->column += RASQAL_GOOD_CAST(int, ulen); locator->byte += RASQAL_GOOD_CAST(int, ulen); } if(unichar > rasqal_unicode_max_codepoint) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "Illegal Unicode character with code point #x%lX (max #x%lX).", unichar, rasqal_unicode_max_codepoint); break; } unichar_width = raptor_unicode_utf8_string_put_char(unichar, dest, 4); if(unichar_width < 0) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "Illegal Unicode character with code point #x%lX.", unichar); break; } /* The destination length is set here to 4 since we know that in * all cases, the UTF-8 encoded output sequence is always shorter * than the input sequence, and the buffer is edited in place. * \uXXXX: 6 bytes input - UTF-8 max 3 bytes output * \uXXXXXXXX: 10 bytes input - UTF-8 max 4 bytes output */ dest += (int)unichar_width; break; default: rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, locator, "Illegal string escape \\%c in \"%s\"", c, (char*)start); return 0; } position++; } /* end while */
static int rasqal_iostream_write_html_literal(rasqal_world* world, raptor_iostream *iostr, rasqal_literal* l) { if(!l) { raptor_iostream_counted_string_write("<span class=\"unbound\">", 22, iostr); raptor_iostream_counted_string_write("unbound", 7, iostr); } else { const unsigned char* str; size_t len; switch(l->type) { case RASQAL_LITERAL_URI: str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->value.uri, &len)); raptor_iostream_counted_string_write("<span class=\"uri\">", 18, iostr); raptor_iostream_counted_string_write("<a href=\"", 9, iostr); raptor_xml_escape_string_write(str, len, '"', iostr); raptor_iostream_counted_string_write("\">", 2, iostr); raptor_xml_escape_string_write(str, len, 0, iostr); raptor_iostream_counted_string_write("</a>", 4, iostr); break; case RASQAL_LITERAL_BLANK: raptor_iostream_counted_string_write("<span class=\"blank\">", 20, iostr); raptor_xml_escape_string_write(l->string, l->string_len, 0, iostr); break; case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_STRING: case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATE: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: raptor_iostream_counted_string_write("<span class=\"literal\">", 22, iostr); raptor_iostream_counted_string_write("<span class=\"value\"", 19, iostr); if(l->language) { str = RASQAL_GOOD_CAST(const unsigned char*, l->language); raptor_iostream_counted_string_write(" xml:lang=\"", 11, iostr); raptor_xml_escape_string_write(str, strlen(l->language), '"', iostr); raptor_iostream_write_byte('"', iostr); } raptor_iostream_write_byte('>', iostr); raptor_xml_escape_string_write(l->string, l->string_len, 0, iostr); raptor_iostream_counted_string_write("</span>", 7, iostr); if(l->datatype) { raptor_iostream_counted_string_write("^^<<span class=\"datatype\">", 29, iostr); str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->datatype, &len)); raptor_xml_escape_string_write(str, len, 0, iostr); raptor_iostream_counted_string_write("</span>>", 11, iostr); } break; case RASQAL_LITERAL_VARIABLE: return rasqal_iostream_write_html_literal(world, iostr, l->value.variable->value); case RASQAL_LITERAL_UNKNOWN: default: rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Cannot turn literal type %d into HTML", l->type); return 1; }