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;
}
static int
rasqal_builtin_agg_expression_execute_step(void* user_data,
raptor_sequence* literals)
{
rasqal_builtin_agg_expression_execute* b;
rasqal_literal* l;
int i;
b = (rasqal_builtin_agg_expression_execute*)user_data;
if(b->error)
return 1;
if(b->expr->op == RASQAL_EXPR_COUNT) {
/* COUNT(*) : counts every row (does not care about literals) */
if(b->expr->arg1->op == RASQAL_EXPR_VARSTAR)
b->count++;
/* COUNT(expr list) : counts rows with non-empty sequence of literals */
else if(raptor_sequence_size(literals) > 0)
b->count++;
return 0;
}
/* Other aggregate functions count every row */
b->count++;
for(i = 0; (l = (rasqal_literal*)raptor_sequence_get_at(literals, i)); i++) {
rasqal_literal* result = NULL;
if(b->expr->op == RASQAL_EXPR_SAMPLE) {
/* Sample chooses the first literal it sees */
if(!b->l)
b->l = rasqal_new_literal_from_literal(l);
break;
}
if(b->expr->op == RASQAL_EXPR_GROUP_CONCAT) {
const unsigned char* str;
int error = 0;
str = (const unsigned char*)rasqal_literal_as_string_flags(l, 0, &error);
if(!error) {
if(raptor_stringbuffer_length(b->sb))
raptor_stringbuffer_append_counted_string(b->sb, b->separator, 1, 1);
raptor_stringbuffer_append_string(b->sb, str, 1);
}
continue;
}
if(!b->l)
result = rasqal_new_literal_from_literal(l);
else {
if(b->expr->op == RASQAL_EXPR_SUM || b->expr->op == RASQAL_EXPR_AVG) {
result = rasqal_literal_add(b->l, l, &b->error);
} else if(b->expr->op == RASQAL_EXPR_MIN) {
int cmp = rasqal_literal_compare(b->l, l, 0, &b->error);
if(cmp <= 0)
result = rasqal_new_literal_from_literal(b->l);
else
result = rasqal_new_literal_from_literal(l);
} else if(b->expr->op == RASQAL_EXPR_MAX) {
int cmp = rasqal_literal_compare(b->l, l, 0, &b->error);
if(cmp >= 0)
result = rasqal_new_literal_from_literal(b->l);
else
result = rasqal_new_literal_from_literal(l);
} else {
RASQAL_FATAL2("Builtin aggregation operation %d is not implemented",
b->expr->op);
}
rasqal_free_literal(b->l);
if(!result)
b->error = 1;
}
b->l = result;
#if RASQAL_DEBUG > 1
RASQAL_DEBUG3("Aggregation step result %s (error=%d)\n",
(result ? (const char*)rasqal_literal_as_string(result) : "(NULL)"),
b->error);
#endif
if(b->error)
break;
}
return b->error;
}
int
main(int argc, char *argv[])
{
const char *program = rasqal_basename(argv[0]);
rasqal_rowsource *rowsource = NULL;
rasqal_world* world = NULL;
rasqal_query* query = NULL;
raptor_sequence* row_seq = NULL;
raptor_sequence* expr_args_seq = NULL;
int failures = 0;
rasqal_variables_table* vt;
rasqal_rowsource *input_rs = NULL;
raptor_sequence* vars_seq = NULL;
raptor_sequence* exprs_seq = NULL;
int test_id;
world = rasqal_new_world();
if(!world || rasqal_world_open(world)) {
fprintf(stderr, "%s: rasqal_world init failed\n", program);
return(1);
}
query = rasqal_new_query(world, "sparql", NULL);
vt = query->vars_table;
for(test_id = 0; test_id < AGGREGATION_TESTS_COUNT; test_id++) {
int input_vars_count = test_data[test_id].input_vars;
int output_rows_count = test_data[test_id].output_rows;
int output_vars_count = test_data[test_id].output_vars;
const int* input_group_ids = test_data[test_id].group_ids;
const int* result_int_data = test_data[test_id].result_data;
const char* const* result_string_data = test_data[test_id].result_string_data;
rasqal_op op = test_data[test_id].op;
raptor_sequence* seq = NULL;
int count;
int size;
int i;
char* output_var_name;
rasqal_variable* output_var;
rasqal_expression* expr;
int output_row_size = (input_vars_count + output_vars_count);
if(output_vars_count != 1) {
fprintf(stderr,
"%s: test %d expects %d variables which is not supported. Test skipped\n",
program, test_id, output_vars_count);
failures++;
goto tidy;
}
row_seq = rasqal_new_row_sequence(world, vt, test_data[test_id].data,
test_data[test_id].input_vars, &vars_seq);
if(row_seq) {
for(i = 0; i < test_data[test_id].input_rows; i++) {
rasqal_row* row = (rasqal_row*)raptor_sequence_get_at(row_seq, i);
row->group_id = input_group_ids[i];
}
input_rs = rasqal_new_rowsequence_rowsource(world, query, vt,
row_seq, vars_seq);
/* vars_seq and row_seq are now owned by input_rs */
vars_seq = row_seq = NULL;
}
if(!input_rs) {
fprintf(stderr, "%s: failed to create rowsequence rowsource\n", program);
failures++;
goto tidy;
}
expr_args_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_expression,
(raptor_data_print_handler)rasqal_expression_print);
if(test_data[test_id].expr_agg_vars[0] != NULL) {
int vindex;
const unsigned char* var_name;
for(vindex = 0;
(var_name = (const unsigned char*)test_data[test_id].expr_agg_vars[vindex] );
vindex++) {
rasqal_variable* v;
rasqal_literal *l = NULL;
rasqal_expression* e = NULL;
v = rasqal_variables_table_get_by_name(vt, var_name);
if(v)
l = rasqal_new_variable_literal(world, v);
if(l)
e = rasqal_new_literal_expression(world, l);
if(e)
raptor_sequence_push(expr_args_seq, e);
else {
fprintf(stderr, "%s: failed to create variable %s\n", program,
(const char*)var_name);
failures++;
goto tidy;
}
}
} /* if vars */
output_var_name = (char*)RASQAL_MALLOC(cstring, 5);
memcpy(output_var_name, "fake", 5);
output_var = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_ANONYMOUS,
(const unsigned char*)output_var_name, NULL);
expr = make_test_expr(world, expr_args_seq, op);
/* expr_args_seq is now owned by expr */
expr_args_seq = NULL;
exprs_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_expression,
(raptor_data_print_handler)rasqal_expression_print);
raptor_sequence_push(exprs_seq, expr);
/* expr is now owned by exprs_seq */
expr = NULL;
vars_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_variable,
(raptor_data_print_handler)rasqal_variable_print);
output_var = rasqal_new_variable_from_variable(output_var);
raptor_sequence_push(vars_seq, output_var);
rowsource = rasqal_new_aggregation_rowsource(world, query, input_rs,
exprs_seq, vars_seq);
/* exprs_seq, vars_seq and input_rs are now owned by rowsource */
exprs_seq = NULL; vars_seq = NULL; input_rs = NULL;
if(!rowsource) {
fprintf(stderr, "%s: failed to create aggregation rowsource\n", program);
failures++;
goto tidy;
}
/* Test the rowsource */
seq = rasqal_rowsource_read_all_rows(rowsource);
if(!seq) {
fprintf(stderr,
"%s: test %d rasqal_rowsource_read_all_rows() returned a NULL seq for a aggregation rowsource\n",
program, test_id);
failures++;
goto tidy;
}
count = raptor_sequence_size(seq);
if(count != output_rows_count) {
fprintf(stderr,
"%s: test %d rasqal_rowsource_read_all_rows() returned %d rows for a aggregation rowsource, expected %d\n",
program, test_id, count, output_rows_count);
failures++;
goto tidy;
}
size = rasqal_rowsource_get_size(rowsource);
if(size != output_row_size) {
fprintf(stderr,
"%s: test %d rasqal_rowsource_get_size() returned %d columns (variables) for a aggregation rowsource, expected %d\n",
program, test_id, size, output_row_size);
failures++;
goto tidy;
}
if(result_int_data) {
for(i = 0; i < output_rows_count; i++) {
rasqal_row* row = (rasqal_row*)raptor_sequence_get_at(seq, i);
rasqal_literal* value;
int integer;
int expected_integer = result_int_data[i];
int vc;
if(row->size != output_row_size) {
fprintf(stderr,
"%s: test %d row #%d is size %d expected %d\n",
program, test_id, i, row->size, output_row_size);
failures++;
goto tidy;
}
/* Expected variable ordering in output row is:
* {input vars} {output_vars}
*/
for(vc = 0; vc < output_vars_count; vc++) {
rasqal_variable* row_var;
int offset = input_vars_count + vc;
row_var = rasqal_rowsource_get_variable_by_offset(rowsource, offset);
value = row->values[offset];
if(!value) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d result is NULL\n",
program, test_id, i, row_var->name, vc);
failures++;
goto tidy;
}
if(value->type != RASQAL_LITERAL_INTEGER) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d result is type %s expected integer\n",
program, test_id, i, row_var->name, vc,
rasqal_literal_type_label(value->type));
failures++;
goto tidy;
}
integer = rasqal_literal_as_integer(value, NULL);
if(integer != expected_integer) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d result is %d expected %d\n",
program, test_id, i, row_var->name, vc,
integer, expected_integer);
failures++;
goto tidy;
}
}
}
}
if(result_string_data) {
for(i = 0; i < output_rows_count; i++) {
rasqal_row* row = (rasqal_row*)raptor_sequence_get_at(seq, i);
rasqal_literal* value;
const unsigned char* str;
const char* expected_string = result_string_data[i];
int vc;
if(row->size != output_row_size) {
fprintf(stderr,
"%s: test %d row #%d is size %d expected %d\n",
program, test_id, i, row->size, output_row_size);
failures++;
goto tidy;
}
/* Expected variable ordering in output row is:
* {input vars} {output_vars}
*/
for(vc = 0; vc < output_vars_count; vc++) {
rasqal_variable* row_var;
int offset = input_vars_count + vc;
row_var = rasqal_rowsource_get_variable_by_offset(rowsource, offset);
value = row->values[offset];
if(!value) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d result is NULL\n",
program, test_id, i, row_var->name, vc);
failures++;
goto tidy;
}
if(value->type != RASQAL_LITERAL_STRING) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d is type %s expected integer\n",
program, test_id, i, row_var->name, vc,
rasqal_literal_type_label(value->type));
failures++;
goto tidy;
}
str = rasqal_literal_as_string(value);
if(strcmp((const char*)str, expected_string)) {
fprintf(stderr,
"%s: test %d row #%d %s value #%d is %s expected %s\n",
program, test_id, i, row_var->name, vc,
str, expected_string);
failures++;
goto tidy;
}
}
}
}
#ifdef RASQAL_DEBUG
rasqal_rowsource_print_row_sequence(rowsource, seq, stderr);
#endif
raptor_free_sequence(seq); seq = NULL;
rasqal_free_rowsource(rowsource); rowsource = NULL;
if(expr_args_seq)
raptor_free_sequence(expr_args_seq);
expr_args_seq = NULL;
}
tidy:
if(exprs_seq)
raptor_free_sequence(exprs_seq);
if(vars_seq)
raptor_free_sequence(vars_seq);
if(expr_args_seq)
raptor_free_sequence(expr_args_seq);
if(rowsource)
rasqal_free_rowsource(rowsource);
if(input_rs)
rasqal_free_rowsource(input_rs);
if(query)
rasqal_free_query(query);
if(world)
rasqal_free_world(world);
return failures;
}
fs_rid fs_hash_rasqal_literal(struct update_context *uc, rasqal_literal *l, int row)
{
if (!l) return FS_RID_NULL;
if (l->type == RASQAL_LITERAL_VARIABLE) {
if (uc->q) {
return fs_binding_get_val(uc->q->bb[0], l->value.variable, row, NULL);
}
fs_error(LOG_ERR, "no variables bound");
return FS_RID_NULL;
}
rasqal_literal_type type = rasqal_literal_get_rdf_term_type(l);
switch (type) {
case RASQAL_LITERAL_URI:
return fs_hash_uri((char *)raptor_uri_as_string(l->value.uri));
case RASQAL_LITERAL_UNKNOWN:
case RASQAL_LITERAL_STRING:
case RASQAL_LITERAL_XSD_STRING: {
fs_rid attr = 0;
if (l->datatype) {
attr = fs_hash_uri((char *)raptor_uri_as_string(l->datatype));
} else if (l->language) {
/* lang tags are normalised to upper case internally */
char *lang = g_ascii_strup((char *)l->language, -1);
attr = fs_hash_literal(lang, 0);
g_free(lang);
}
return fs_hash_literal((char *)rasqal_literal_as_string(l), attr);
}
case RASQAL_LITERAL_BLANK: {
raptor_term_blank_value bnode;
bnode.string = (unsigned char *)rasqal_literal_as_string(l);
bnode.string_len = strlen((char *)bnode.string);
return fs_bnode_id(uc->link, bnode);
}
case RASQAL_LITERAL_VARIABLE:
case RASQAL_LITERAL_QNAME:
case RASQAL_LITERAL_PATTERN:
case RASQAL_LITERAL_BOOLEAN:
case RASQAL_LITERAL_INTEGER:
case RASQAL_LITERAL_INTEGER_SUBTYPE:
case RASQAL_LITERAL_DECIMAL:
case RASQAL_LITERAL_FLOAT:
case RASQAL_LITERAL_DOUBLE:
case RASQAL_LITERAL_DATETIME:
case RASQAL_LITERAL_UDT:
#if RASQAL_VERSION >= 929
case RASQAL_LITERAL_DATE:
#endif
break;
}
fs_error(LOG_ERR, "bad rasqal literal (type %d)", type);
return FS_RID_NULL;
}
static void navigator_graph_pattern_load(rasqal_graph_pattern *gp, int gp_index,int indent, GSList** template_query_)
{
int triple_index = 0;
raptor_sequence *seq;
rasqal_variable * var;
rasqal_triple* t;
rasqal_literal_type type;
GSList* template_query= *template_query_;
indent += 1;
/* look for triples */
while(1) {
t = rasqal_graph_pattern_get_triple(gp, triple_index);
if(!t)
break;
/*
rasqal_literal_type type;
printf ("triple\n");
type=rasqal_literal_get_rdf_term_type(t->subject);
printf ("S type %d val %s\n", type, rasqal_literal_as_string (t->subject)) ;
type=rasqal_literal_get_rdf_term_type(t->predicate);
printf ("P type %d val %s\n", type, rasqal_literal_as_string (t->predicate)) ;
type=rasqal_literal_get_rdf_term_type(t->object);
printf ("O type %d val %s\n", type, rasqal_literal_as_string (t->object)) ;
*/
//ssTriple_t *ttemp = (ssTriple_t *)g_new0(ssTriple_t,1);
ssTriple_t_sparql *ttemp = (ssTriple_t_sparql *)g_new0(ssTriple_t_sparql,1);
type=rasqal_literal_get_rdf_term_type(t->subject);
//var=rasqal_literal_as_variable(t->subject);
//rasqal_variable_print(var, stdout);
//printf("\n");
//printf("%s\n", var->name);
//rasqal_free_variable (var);
if ((type==RASQAL_LITERAL_UNKNOWN) && (rasqal_literal_as_string(t->subject) == NULL))
{ //variable , needs a wildcard
var=rasqal_literal_as_variable(t->subject);
ttemp->subject_var=g_strdup(var->name);
rasqal_free_variable (var);
ttemp->subject=g_strdup_printf("%s",wildcard1);
}
else
{ ttemp->subject=g_strdup(rasqal_literal_as_string (t->subject));
ttemp->subject_var=NULL;
}
type=rasqal_literal_get_rdf_term_type(t->predicate);
if ((type==RASQAL_LITERAL_UNKNOWN) && (rasqal_literal_as_string(t->predicate) == NULL))
{ //variable , needs a wildcard
var=rasqal_literal_as_variable(t->predicate);
ttemp->predicate_var=g_strdup(var->name);
rasqal_free_variable (var);
ttemp->predicate=g_strdup_printf("%s",wildcard1);
}
else
{ ttemp->predicate=g_strdup(rasqal_literal_as_string (t->predicate));
ttemp->predicate_var=NULL;
}
type=rasqal_literal_get_rdf_term_type(t->object);
if ((type==RASQAL_LITERAL_UNKNOWN) && (rasqal_literal_as_string(t->object) == NULL))
{ //variable , needs a wildcard
var=rasqal_literal_as_variable(t->object);
ttemp->object_var=g_strdup(var->name);
rasqal_free_variable (var);
ttemp->object=g_strdup_printf("%s",wildcard1);
}
else
{
if (type==RASQAL_LITERAL_STRING)
{ ttemp->object=g_strdup(rasqal_literal_as_string (t->object));
ttemp->objType = ssElement_TYPE_LIT;
}
else
{ ttemp->object=g_strdup(rasqal_literal_as_string (t->object));
ttemp->objType = ssElement_TYPE_URI;
}
ttemp->object_var=NULL;
}
ttemp->gp_index=gp_index;
ttemp->indent=indent;
//printf("SPARQL Binding triple is: \t%s\t%s\t%s , obj_Type %d \n", ttemp->subject, ttemp->predicate, ttemp->object, ttemp->objType);
//printf(" Vars: \t%s\t%s\t%s , gp_index %d indent %d\n", ttemp->subject_var, ttemp->predicate_var, ttemp->object_var,ttemp->gp_index,ttemp->indent);
template_query= g_slist_prepend(template_query, ttemp);
triple_index++;
}
/* look for sub-graph patterns */
seq = rasqal_graph_pattern_get_sub_graph_pattern_sequence(gp);
if(seq && raptor_sequence_size(seq) > 0) {
gp_index = 0;
while(1)
{
rasqal_graph_pattern* sgp;
sgp = rasqal_graph_pattern_get_sub_graph_pattern(gp, gp_index);
if(!sgp)
break;
navigator_graph_pattern_load(sgp, gp_index, indent + 1, &template_query);
gp_index++;
}
}
indent -= 1;
*template_query_=template_query;
}
