/**
* 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;
}
