/*
* rasqal_expression_evaluate_datatype:
* @e: The expression to evaluate.
* @eval_context: Evaluation context
*
* INTERNAL - Evaluate RASQAL_EXPR_DATATYPE (string literal) expression.
*
* Return value: A #rasqal_literal URI value or NULL on failure.
*/
static rasqal_literal*
rasqal_expression_evaluate_datatype(rasqal_expression *e,
rasqal_evaluation_context *eval_context,
int *error_p)
{
rasqal_world* world = eval_context->world;
rasqal_literal* l1;
int free_literal = 1;
rasqal_variable* v = NULL;
raptor_uri* dt_uri = NULL;
l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p);
if(*error_p || !l1)
goto failed;
v = rasqal_literal_as_variable(l1);
if(v) {
rasqal_free_literal(l1);
l1 = v->value; /* don't need v after this */
free_literal = 0;
if(!l1)
goto failed;
}
if(rasqal_literal_get_rdf_term_type(l1) != RASQAL_LITERAL_STRING)
goto failed;
if(l1->language)
goto failed;
/* The datatype of a plain literal is xsd:string */
dt_uri = l1->datatype;
if(!dt_uri && l1->type == RASQAL_LITERAL_STRING)
dt_uri = rasqal_xsd_datatype_type_to_uri(l1->world,
RASQAL_LITERAL_XSD_STRING);
if(!dt_uri)
goto failed;
dt_uri = raptor_uri_copy(dt_uri);
if(free_literal)
rasqal_free_literal(l1);
/* after this dt_uri is owned by result */
return rasqal_new_uri_literal(world, dt_uri);
failed:
if(error_p)
*error_p = 1;
if(free_literal)
rasqal_free_literal(l1);
return NULL;
}
rasqal_literal*
redland_node_to_rasqal_literal(librdf_world* world, librdf_node *node)
{
rasqal_literal* l;
if(librdf_node_is_resource(node)) {
raptor_uri* uri=(raptor_uri*)librdf_new_uri_from_uri(librdf_node_get_uri(node));
l=rasqal_new_uri_literal(world->rasqal_world_ptr, uri); /* transfer uri ownership to literal */
} else if(librdf_node_is_literal(node)) {
unsigned char *string;
librdf_uri *uri;
unsigned char *new_string;
char *new_language=NULL;
raptor_uri *new_datatype=NULL;
size_t len;
string=librdf_node_get_literal_value_as_counted_string(node, &len);
new_string=(unsigned char*)rasqal_alloc_memory(len+1);
if(!new_string)
return NULL;
strcpy((char*)new_string, (const char*)string);
string=(unsigned char*)librdf_node_get_literal_value_language(node);
if(string) {
new_language=(char*)rasqal_alloc_memory(strlen((const char*)string)+1);
if(!new_language) {
rasqal_free_memory((void*)new_string);
return NULL;
}
strcpy((char*)new_language, (const char*)string);
}
uri=librdf_node_get_literal_value_datatype_uri(node);
if(uri)
new_datatype=(raptor_uri*)librdf_new_uri_from_uri(uri);
/* transfer new_string,new_language,new_datatype ownership to literal */
l = rasqal_new_string_literal(world->rasqal_world_ptr, (const unsigned char*)new_string, new_language, new_datatype, NULL);
} else {
unsigned char *blank=librdf_node_get_blank_identifier(node);
unsigned char *new_blank;
if(!blank)
return NULL;
new_blank=(unsigned char*)rasqal_alloc_memory(strlen((const char*)blank)+1);
if(!new_blank)
return NULL;
strcpy((char*)new_blank, (const char*)blank);
/* transfer new_blank ownership to literal */
l = rasqal_new_simple_literal(world->rasqal_world_ptr, RASQAL_LITERAL_BLANK, (const unsigned char*)new_blank);
}
return l;
}
static int
rasqal_graph_next_dg(rasqal_graph_rowsource_context *con)
{
rasqal_query *query = con->rowsource->query;
rasqal_data_graph *dg;
con->finished = 0;
while(1) {
rasqal_literal *o;
con->dg_offset++;
dg = rasqal_query_get_data_graph(query, con->dg_offset);
if(!dg) {
con->finished = 1;
break;
}
if(!dg->name_uri)
continue;
o = rasqal_new_uri_literal(query->world, raptor_uri_copy(dg->name_uri));
if(!o) {
RASQAL_DEBUG1("Failed to create new URI literal\n");
con->finished = 1;
break;
}
RASQAL_DEBUG2("Using data graph URI literal <%s>\n",
rasqal_literal_as_string(o));
rasqal_rowsource_set_origin(con->rowsource, o);
/* this passes ownership of o to con->var */
rasqal_variable_set_value(con->var, o);
break;
}
return con->finished;
}
/*
* rasqal_expression_evaluate_uri_constructor:
* @e: The expression to evaluate.
* @eval_context: Evaluation context
*
* INTERNAL - Evaluate RASQAL_EXPR_URI and RASQAL_EXPR_IRI (string)
* expressions.
*
* Return value: A #rasqal_literal URI value or NULL on failure.
*/
static rasqal_literal*
rasqal_expression_evaluate_uri_constructor(rasqal_expression *e,
rasqal_evaluation_context *eval_context,
int *error_p)
{
rasqal_world* world = eval_context->world;
rasqal_literal* l1;
raptor_uri* dt_uri;
const unsigned char *s;
l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p);
if(*error_p || !l1)
goto failed;
s = rasqal_literal_as_string_flags(l1, eval_context->flags, error_p);
if(*error_p)
goto failed;
dt_uri = raptor_new_uri_relative_to_base(world->raptor_world_ptr,
eval_context->base_uri,
s);
rasqal_free_literal(l1); l1 = NULL;
if(!dt_uri)
goto failed;
/* after this dt_uri is owned by the result literal */
return rasqal_new_uri_literal(world, dt_uri);
failed:
if(error_p)
*error_p = 1;
if(l1)
rasqal_free_literal(l1);
return NULL;
}
manifest_world*
manifest_new_world(rasqal_world* world)
{
manifest_world* mw;
raptor_world* raptor_world_ptr = rasqal_world_get_raptor(world);
mw = (manifest_world*)calloc(sizeof(*mw), 1);
if(!mw)
return NULL;
mw->world = world;
mw->raptor_world_ptr = raptor_world_ptr;
/* Create Namespace URIs, concept URIs and rasqal literal concepts */
mw->rdfs_namespace_uri = raptor_new_uri(raptor_world_ptr, raptor_rdf_schema_namespace_uri);
mw->mf_namespace_uri = raptor_new_uri(raptor_world_ptr, (const unsigned char*)"http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#");
mw->t_namespace_uri = raptor_new_uri(raptor_world_ptr, (const unsigned char*)"http://ns.librdf.org/2009/test-manifest#");
mw->qt_namespace_uri = raptor_new_uri(raptor_world_ptr, (const unsigned char*)"http://www.w3.org/2001/sw/DataAccess/tests/test-query#");
mw->dawgt_namespace_uri = raptor_new_uri(raptor_world_ptr, (const unsigned char*)"http://www.w3.org/2001/sw/DataAccess/tests/test-dawg#");
mw->sd_namespace_uri = raptor_new_uri(raptor_world_ptr, (const unsigned char*)"http://www.w3.org/ns/sparql-service-description#");
mw->mf_Manifest_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->mf_namespace_uri, (const unsigned char*)"Manifest");
mw->mf_entries_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->mf_namespace_uri, (const unsigned char*)"entries");
mw->mf_name_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->mf_namespace_uri, (const unsigned char*)"name");
mw->mf_action_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->mf_namespace_uri, (const unsigned char*)"action");
mw->mf_result_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->mf_namespace_uri, (const unsigned char*)"result");
mw->mf_resultCardinality_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->mf_namespace_uri, (const unsigned char*)"resultCardinality");
mw->rdf_type_uri = raptor_new_uri_for_rdf_concept(raptor_world_ptr, (const unsigned char*)"type");
mw->rdf_first_uri = raptor_new_uri_for_rdf_concept(raptor_world_ptr, (const unsigned char*)"first");
mw->rdf_rest_uri = raptor_new_uri_for_rdf_concept(raptor_world_ptr, (const unsigned char*)"rest");
mw->rdf_nil_uri = raptor_new_uri_for_rdf_concept(raptor_world_ptr, (const unsigned char*)"nil");
mw->rdfs_comment_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->rdfs_namespace_uri, (const unsigned char*)"comment");
mw->t_path_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->t_namespace_uri, (const unsigned char*)"path");
mw->qt_data_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->qt_namespace_uri, (const unsigned char*)"data");
mw->qt_graphData_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->qt_namespace_uri, (const unsigned char*)"graphData");
mw->qt_query_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->qt_namespace_uri, (const unsigned char*)"query");
mw->dawgt_approval_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->dawgt_namespace_uri, (const unsigned char*)"approval");
mw->sd_entailmentRegime_uri = raptor_new_uri_from_uri_local_name(raptor_world_ptr, mw->sd_namespace_uri, (const unsigned char*)"entailmentRegime");
mw->mf_Manifest_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->mf_Manifest_uri));
mw->mf_entries_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->mf_entries_uri));
mw->mf_name_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->mf_name_uri));
mw->mf_action_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->mf_action_uri));
mw->mf_result_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->mf_result_uri));
mw->mf_resultCardinality_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->mf_resultCardinality_uri));
mw->rdf_type_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->rdf_type_uri));
mw->rdf_first_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->rdf_first_uri));
mw->rdf_rest_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->rdf_rest_uri));
mw->rdfs_comment_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->rdfs_comment_uri));
mw->t_path_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->t_path_uri));
mw->qt_data_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->qt_data_uri));
mw->qt_graphData_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->qt_graphData_uri));
mw->qt_query_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->qt_query_uri));
mw->dawgt_approval_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->dawgt_approval_uri));
mw->sd_entailmentRegime_literal = rasqal_new_uri_literal(world, raptor_uri_copy(mw->sd_entailmentRegime_uri));
return mw;
}
static void
rasqal_sparql_xml_sax2_end_element_handler(void *user_data,
raptor_xml_element* xml_element)
{
rasqal_rowsource_sparql_xml_context* con;
raptor_qname* name;
int i;
rasqal_sparql_xml_read_state state=STATE_unknown;
con=(rasqal_rowsource_sparql_xml_context*)user_data;
name=raptor_xml_element_get_name(xml_element);
for(i=STATE_first; i <= STATE_last; i++) {
if(!strcmp((const char*)raptor_qname_get_local_name(name),
sparql_xml_element_names[i])) {
state=(rasqal_sparql_xml_read_state)i;
con->state=state;
}
}
if(state == STATE_unknown) {
fprintf(stderr, "UNKNOWN element %s\n", raptor_qname_get_local_name(name));
con->failed++;
}
con->depth--;
#ifdef TRACE_XML
if(con->trace) {
pad(stderr, con->depth);
fprintf(stderr, "End Element %s (%d)\n", raptor_qname_get_local_name(name),
con->state);
}
#endif
switch(con->state) {
case STATE_head:
/* Only now is the full number of variables known */
con->variables_count = rasqal_variables_table_get_named_variables_count(con->vars_table);
con->rowsource->size = con->variables_count;
break;
case STATE_literal:
if(1) {
rasqal_literal* l;
unsigned char* lvalue;
raptor_uri* datatype_uri=NULL;
char* language_str=NULL;
lvalue=(unsigned char*)RASQAL_MALLOC(cstring, con->value_len+1);
memcpy(lvalue, con->value, con->value_len + 1);
if(con->datatype)
datatype_uri = raptor_new_uri(con->world->raptor_world_ptr, (const unsigned char*)con->datatype);
if(con->language) {
size_t language_len = strlen(con->language);
language_str=(char*)RASQAL_MALLOC(cstring, language_len + 1);
memcpy(language_str, con->language, language_len + 1);
}
l = rasqal_new_string_literal_node(con->world, lvalue, language_str,
datatype_uri);
rasqal_row_set_value_at(con->row, con->result_offset, l);
rasqal_free_literal(l);
RASQAL_DEBUG3("Saving row result %d string value at offset %d\n",
con->offset, con->result_offset);
}
break;
case STATE_bnode:
if(1) {
rasqal_literal* l;
unsigned char* lvalue;
lvalue=(unsigned char*)RASQAL_MALLOC(cstring, con->value_len+1);
memcpy(lvalue, con->value, con->value_len + 1);
l = rasqal_new_simple_literal(con->world, RASQAL_LITERAL_BLANK, lvalue);
rasqal_row_set_value_at(con->row, con->result_offset, l);
rasqal_free_literal(l);
RASQAL_DEBUG3("Saving row result %d bnode value at offset %d\n",
con->offset, con->result_offset);
}
break;
case STATE_uri:
if(1) {
raptor_uri* uri;
rasqal_literal* l;
uri = raptor_new_uri(con->world->raptor_world_ptr, (const unsigned char*)con->value);
l = rasqal_new_uri_literal(con->world, uri);
rasqal_row_set_value_at(con->row, con->result_offset, l);
rasqal_free_literal(l);
RASQAL_DEBUG3("Saving row result %d uri value at offset %d\n",
con->offset, con->result_offset);
}
break;
case STATE_result:
if(con->row) {
RASQAL_DEBUG2("Saving row result %d\n", con->offset);
raptor_sequence_push(con->results_sequence, con->row);
}
con->row=NULL;
break;
case STATE_unknown:
case STATE_sparql:
case STATE_variable:
case STATE_results:
case STATE_binding:
default:
break;
}
if(con->value) {
RASQAL_FREE(cstring, con->value);
con->value=NULL;
}
}
/**
* rasqal_new_row_sequence:
* @world: world object ot use
* @vt: variables table to use to declare variables
* @row_data: row data
* @vars_count: number of variables in row
* @vars_seq_p: OUT parameter - pointer to place to store sequence of variables (or NULL)
*
* INTERNAL - Make a sequence of #rasqal_row* objects
* with variables defined into the @vt table and values in the sequence
*
* The @row_data parameter is an array of strings forming a table of
* width (vars_count * 2).
* The first row is a list of variable names at offset 0.
* The remaining rows are values where offset 0 is a literal and
* offset 1 is a URI string.
*
* The last row is indicated by an entire row of NULLs.
*
* Return value: sequence of rows or NULL on failure
*/
raptor_sequence*
rasqal_new_row_sequence(rasqal_world* world,
rasqal_variables_table* vt,
const char* const row_data[],
int vars_count,
raptor_sequence** vars_seq_p)
{
raptor_sequence *seq = NULL;
raptor_sequence *vars_seq = NULL;
int row_i;
int column_i;
int failed = 0;
#define GET_CELL(row, column, offset) \
row_data[((((row)*vars_count)+(column))<<1)+(offset)]
seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_row,
(raptor_data_print_handler)rasqal_row_print);
if(!seq)
return NULL;
if(vars_seq_p) {
vars_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_variable,
(raptor_data_print_handler)rasqal_variable_print);
if(!vars_seq) {
raptor_free_sequence(seq);
return NULL;
}
}
/* row 0 is variables */
row_i = 0;
for(column_i = 0; column_i < vars_count; column_i++) {
const char * var_name = GET_CELL(row_i, column_i, 0);
size_t var_name_len = strlen(var_name);
const unsigned char* name;
rasqal_variable* v;
name = (unsigned char*)RASQAL_MALLOC(cstring, var_name_len+1);
if(!name) {
failed = 1;
goto tidy;
}
memcpy((void*)name, var_name, var_name_len + 1);
v = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_NORMAL, name, NULL);
if(!v) {
failed = 1;
goto tidy;
}
if(vars_seq) {
v = rasqal_new_variable_from_variable(v);
raptor_sequence_push(vars_seq, v);
}
}
for(row_i = 1; 1; row_i++) {
rasqal_row* row;
int data_values_seen = 0;
/* Terminate on an entire row of NULLs */
for(column_i = 0; column_i < vars_count; column_i++) {
if(GET_CELL(row_i, column_i, 0) || GET_CELL(row_i, column_i, 1)) {
data_values_seen++;
break;
}
}
if(!data_values_seen)
break;
row = rasqal_new_row_for_size(world, vars_count);
if(!row) {
raptor_free_sequence(seq); seq = NULL;
goto tidy;
}
for(column_i = 0; column_i < vars_count; column_i++) {
rasqal_literal* l = NULL;
if(GET_CELL(row_i, column_i, 0)) {
/* string literal */
const char* str = GET_CELL(row_i, column_i, 0);
size_t str_len = strlen(str);
char *eptr = NULL;
int integer;
integer = (int)strtol((const char*)str, &eptr, 10);
if(!*eptr) {
/* is an integer */
l = rasqal_new_integer_literal(world, RASQAL_LITERAL_INTEGER,
integer);
} else {
unsigned char *val;
val = (unsigned char*)RASQAL_MALLOC(cstring, str_len+1);
if(val) {
memcpy(val, str, str_len + 1);
l = rasqal_new_string_literal_node(world, val, NULL, NULL);
} else
failed = 1;
}
} else if(GET_CELL(row_i, column_i, 1)) {
/* URI */
const unsigned char* str;
raptor_uri* u;
str = (const unsigned char*)GET_CELL(row_i, column_i, 1);
u = raptor_new_uri(world->raptor_world_ptr, str);
if(u)
l = rasqal_new_uri_literal(world, u);
else
failed = 1;
} else {
/* variable is not defined for this row */
continue;
}
if(!l) {
rasqal_free_row(row);
failed = 1;
goto tidy;
}
rasqal_row_set_value_at(row, column_i, l);
/* free our copy of literal, rasqal_row has a reference */
rasqal_free_literal(l);
}
raptor_sequence_push(seq, row);
}
tidy:
if(failed) {
if(seq) {
raptor_free_sequence(seq);
seq = NULL;
}
if(vars_seq) {
raptor_free_sequence(vars_seq);
vars_seq = NULL;
}
} else {
if(vars_seq) {
if(vars_seq_p)
*vars_seq_p = vars_seq;
else
raptor_free_sequence(vars_seq);
}
}
return seq;
}
/*
* rasqal_expression_evaluate_uuid:
* @e: The expression to evaluate.
* @eval_context: Evaluation context
* @want_uri: non-0 to return URI otherwise string
*
* INTERNAL - Evaluate SPARQL 1.1 RASQAL_EXPR_UUID, RASQAL_EXPR_STRUUID
*
* Return value: A #rasqal_literal URI / string value or NULL on failure.
*/
static rasqal_literal*
rasqal_expression_evaluate_uuid(rasqal_expression *e,
rasqal_evaluation_context *eval_context,
int *error_p,
int want_uri)
{
#ifdef RASQAL_UUID_NONE
return NULL;
#else
rasqal_world* world = eval_context->world;
#if defined(RASQAL_UUID_OSSP)
uuid_t* data;
#else
uuid_t data; /* static */
int i;
#endif
size_t output_len = RASQAL_UUID_STRING_LEN;
unsigned char* output;
unsigned char* p;
#if defined(RASQAL_UUID_LIBUUID) || defined(RASQAL_UUID_LIBC)
uuid_generate(data);
#endif
#if defined(RASQAL_UUID_OSSP)
uuid_create(&data);
uuid_make(data, UUID_MAKE_V1);
#endif
#ifdef RASQAL_UUID_INTERNAL
rasqal_uuid_generate(eval_context, data);
#endif
if(want_uri)
output_len += RASQAL_UUID_URI_PREFIX_LEN;
output = RASQAL_MALLOC(unsigned char*, output_len + 1);
if(!output) {
#if defined(RASQAL_UUID_OSSP)
uuid_destroy(data);
#endif
return NULL;
}
p = output;
if(want_uri) {
memcpy(p, RASQAL_UUID_URI_PREFIX, RASQAL_UUID_URI_PREFIX_LEN);
p += RASQAL_UUID_URI_PREFIX_LEN;
}
#if defined(RASQAL_UUID_OSSP)
uuid_export(data, UUID_FMT_STR, p, /* data_len */ NULL);
uuid_destroy(data);
#else
for(i = 0; i < RASQAL_UUID_LEN; i++) {
unsigned short hex;
unsigned char c = data[i];
hex = (c & 0xf0) >> 4;
*p++ = (hex < 10) ? ('0' + hex) : ('a' + hex - 10);
hex = (c & 0x0f);
*p++ = (hex < 10) ? ('0' + hex) : ('a' + hex - 10);
if(i == 3 || i == 5 || i == 7 || i == 9)
*p++ = '-';
}
*p = '\0';
#endif /* end if !RASQAL_UUID_OSSP */
/* after this output becomes owned by result */
if(want_uri) {
raptor_uri* u;
rasqal_literal* l = NULL;
u = raptor_new_uri(world->raptor_world_ptr, output);
if(u)
l = rasqal_new_uri_literal(world, u);
RASQAL_FREE(char*, output);
return l;
} else {
return rasqal_new_string_literal(world, output, NULL, NULL, NULL);
}
#endif
}
