int
rasqal_update_operation_print(rasqal_update_operation *update, FILE* stream)
{
int is_always_2_args = (update->type >= RASQAL_UPDATE_TYPE_ADD &&
update->type <= RASQAL_UPDATE_TYPE_COPY);
fputs("update-operation(type=", stream);
fputs(rasqal_update_type_label(update->type), stream);
if(update->graph_uri || is_always_2_args) {
fputs(", graph-uri=", stream);
if(update->graph_uri)
raptor_uri_print(update->graph_uri, stream);
else
fputs("default", stream);
}
if(update->document_uri || is_always_2_args) {
fputs(", document-uri=", stream);
if(update->document_uri)
raptor_uri_print(update->document_uri, stream);
else
fputs("default", stream);
}
switch(update->applies) {
case RASQAL_UPDATE_GRAPH_ONE:
fputs(", applies: one graph", stream);
break;
case RASQAL_UPDATE_GRAPH_DEFAULT:
fputs(", applies: default", stream);
break;
case RASQAL_UPDATE_GRAPH_NAMED:
fputs(", applies: named", stream);
break;
case RASQAL_UPDATE_GRAPH_ALL:
fputs(", applies: all", stream);
break;
}
if(update->insert_templates) {
fputs(", insert-templates=", stream);
raptor_sequence_print(update->insert_templates, stream);
}
if(update->delete_templates) {
fputs(", delete-templates=", stream);
raptor_sequence_print(update->delete_templates, stream);
}
if(update->where) {
fputs(", where=", stream);
rasqal_graph_pattern_print(update->where, stream);
}
fputc(')', stream);
return 0;
}
static int
#else
static void
#endif
rasqal_rowsource_groupby_tree_print_node(void *object, FILE *fh)
{
rasqal_groupby_tree_node* node = (rasqal_groupby_tree_node*)object;
fputs("Group\n Key Sequence of literals: ", fh);
if(node->literals)
/* sequence of literals */
raptor_sequence_print(node->literals, fh);
else
fputs("None", fh);
fputs("\n Value Sequence of rows:\n", fh);
if(node->rows) {
int i;
int size = raptor_sequence_size(node->rows);
/* sequence of rows */
for(i = 0; i < size; i++) {
rasqal_row* row = (rasqal_row*)raptor_sequence_get_at(node->rows, i);
fprintf(fh, " Row %d: ", i);
rasqal_row_print(row, fh);
fputc('\n', fh);
}
} else
fputs("None\n", fh);
#ifdef HAVE_RAPTOR2_API
return 0;
#endif
}
static int
raptor_avltree_print(raptor_avltree* tree, FILE* stream)
{
if(!tree)
return 1;
fprintf(stream, "Group sequence with %d groups\n",
raptor_sequence_size(tree->seq));
raptor_sequence_print(tree->seq, stream);
return 0;
}
int
rasqal_formula_print(rasqal_formula* formula, FILE *stream)
{
RASQAL_ASSERT_OBJECT_POINTER_RETURN_VALUE(formula, rasqal_formula, 1);
RASQAL_ASSERT_OBJECT_POINTER_RETURN_VALUE(stream, FILE*, 1);
fputs("formula(triples=", stream);
if(formula->triples)
raptor_sequence_print(formula->triples, stream);
else
fputs("[]", stream);
fputs(", value=", stream);
if(formula->value)
rasqal_literal_print(formula->value, stream);
else
fputs("NULL", stream);
fputc(')', stream);
return 0;
}
static rasqal_row*
rasqal_aggregation_rowsource_read_row(rasqal_rowsource* rowsource,
void *user_data)
{
rasqal_aggregation_rowsource_context* con;
rasqal_row* row;
int error = 0;
con = (rasqal_aggregation_rowsource_context*)user_data;
if(con->finished)
return NULL;
/* Iterate over input rows until last row seen or group done */
while(1) {
error = 0;
if(con->saved_row)
row = con->saved_row;
else
row = rasqal_rowsource_read_row(con->rowsource);
if(!row) {
/* End of input - calculate last aggregation result */
con->finished = 1;
break;
}
if(con->last_group_id != row->group_id) {
int i;
if(!con->saved_row && con->last_group_id >= 0) {
/* Existing aggregation is done - return result */
/* save current row for next time this function is called */
con->saved_row = row;
row = NULL;
#ifdef RASQAL_DEBUG
RASQAL_DEBUG2("Aggregation ending group %d", con->last_group_id);
fputc('\n', DEBUG_FH);
#endif
/* Empty distinct maps */
for(i = 0; i < con->expr_count; i++) {
rasqal_agg_expr_data* expr_data = &con->expr_data[i];
if(expr_data->map) {
rasqal_free_map(expr_data->map);
expr_data->map = NULL;
}
}
break;
}
/* reference is now in 'row' variable */
con->saved_row = NULL;
#ifdef RASQAL_DEBUG
RASQAL_DEBUG2("Aggregation starting group %d", row->group_id);
fputc('\n', DEBUG_FH);
#endif
/* next time this function is called we continue here */
for(i = 0; i < con->expr_count; i++) {
rasqal_agg_expr_data* expr_data = &con->expr_data[i];
if(!expr_data->agg_user_data) {
/* init once */
expr_data->agg_user_data = rasqal_builtin_agg_expression_execute_init(rowsource->world,
expr_data->expr);
if(!expr_data->agg_user_data) {
error = 1;
break;
}
}
/* Init map for each group */
if(expr_data->expr->flags & RASQAL_EXPR_FLAG_DISTINCT) {
expr_data->map = rasqal_new_literal_sequence_sort_map(1 /* is_distinct */,
0 /* compare_flags */);
if(!expr_data->map) {
error = 1;
break;
}
}
}
if(error)
break;
con->last_group_id = row->group_id;
} /* end if handling change of group ID */
/* Bind the values in the input row to the variables in the table */
rasqal_row_bind_variables(row, rowsource->query->vars_table);
/* Evaluate the expressions giving a sequence of literals to
* run the aggregation step over.
*/
if(1) {
int i;
if(!con->step_count) {
/* copy first value row from input rowsource */
for(i = 0; i < con->input_values_count; i++) {
rasqal_literal* value;
value = rasqal_new_literal_from_literal(row->values[i]);
raptor_sequence_set_at(con->input_values, i, value);
}
}
con->step_count++;
for(i = 0; i < con->expr_count; i++) {
rasqal_agg_expr_data* expr_data = &con->expr_data[i];
raptor_sequence* seq;
/* SPARQL Aggregation uses ListEvalE() to evaluate - ignoring
* errors and filtering out expressions that fail
*/
seq = rasqal_expression_sequence_evaluate(rowsource->query,
expr_data->exprs_seq,
/* ignore_errors */ 1,
&error);
if(error)
continue;
if(expr_data->map) {
if(rasqal_literal_sequence_sort_map_add_literal_sequence(expr_data->map,
seq)) {
/* duplicate found
*
* The above function just freed seq so no data is lost
*/
continue;
}
}
#ifdef RASQAL_DEBUG
RASQAL_DEBUG1("Aggregation step over literals: ");
raptor_sequence_print(seq, DEBUG_FH);
fputc('\n', DEBUG_FH);
#endif
error = rasqal_builtin_agg_expression_execute_step(expr_data->agg_user_data,
seq);
/* when DISTINCTing, seq remains owned by the map
* otherwise seq is local and must be freed
*/
if(!expr_data->map)
raptor_free_sequence(seq);
if(error)
break;
}
}
rasqal_free_row(row); row = NULL;
if(error)
break;
} /* end while reading rows */
if(error) {
/* Discard row on error */
if(row) {
rasqal_free_row(row);
row = NULL;
}
} else if (con->last_group_id >= 0) {
int offset = 0;
int i;
/* Generate result row and reset for next group */
row = rasqal_new_row(rowsource);
/* Copy scalar results through */
for(i = 0; i < con->input_values_count; i++) {
rasqal_literal* result;
/* Reset: get and delete any stored input rowsource literal */
result = (rasqal_literal*)raptor_sequence_delete_at(con->input_values, i);
rasqal_row_set_value_at(row, offset, result);
rasqal_free_literal(result);
offset++;
}
/* Set aggregate results */
for(i = 0; i < con->expr_count; i++) {
rasqal_literal* result;
rasqal_agg_expr_data* expr_data = &con->expr_data[i];
rasqal_variable* v;
/* Calculate the result because the input ended or a new group started */
result = rasqal_builtin_agg_expression_execute_result(expr_data->agg_user_data);
#ifdef RASQAL_DEBUG
RASQAL_DEBUG1("Aggregation ending group with result: ");
if(result)
rasqal_literal_print(result, DEBUG_FH);
else
fputs("NULL", DEBUG_FH);
fputc('\n', DEBUG_FH);
#endif
v = rasqal_rowsource_get_variable_by_offset(rowsource, offset);
result = rasqal_new_literal_from_literal(result);
/* it is OK to bind to NULL */
rasqal_variable_set_value(v, result);
rasqal_row_set_value_at(row, offset, result);
if(result)
rasqal_free_literal(result);
offset++;
if(rasqal_builtin_agg_expression_execute_reset(expr_data->agg_user_data)) {
rasqal_free_row(row);
row = NULL;
break;
}
}
con->step_count = 0;
if(row)
row->offset = con->offset++;
}
return row;
}
int
main(int argc, char *argv[])
{
raptor_sequence* seq=raptor_new_sequence(NULL, (raptor_print_handler*)raptor_sequence_print_string);
char *s;
program=argv[0];
raptor_sequence_set_at(seq, 0, (void*)"first");
raptor_sequence_push(seq, (void*)"third");
raptor_sequence_shift(seq, (void*)"second");
s=(char*)raptor_sequence_get_at(seq, 0);
assert_match(raptor_sequence_get_at, s, "second");
s=(char*)raptor_sequence_get_at(seq, 1);
assert_match(raptor_sequence_get_at, s, "first");
s=(char*)raptor_sequence_get_at(seq, 2);
assert_match(raptor_sequence_get_at, s, "third");
if(raptor_sequence_size(seq) !=3)
exit(1);
fprintf(stderr, "%s: sequence after additions: ", program);
raptor_sequence_print(seq, stderr);
fputc('\n', stderr);
/* now made alphabetical i.e. first, second, third */
raptor_sequence_sort(seq, raptor_compare_strings);
fprintf(stderr, "%s: sequence after sort: ", program);
raptor_sequence_print(seq, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_pop(seq);
assert_match(raptor_sequence_get_at, s, "third");
if(raptor_sequence_size(seq) !=2)
exit(1);
fprintf(stderr, "%s: sequence after pop: ", program);
raptor_sequence_print(seq, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_unshift(seq);
assert_match(raptor_sequence_get_at, s, "first");
if(raptor_sequence_size(seq) !=1)
exit(1);
fprintf(stderr, "%s: sequence after unshift: ", program);
raptor_sequence_print(seq, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_get_at(seq, 0);
assert_match(raptor_sequence_get_at, s, "second");
raptor_free_sequence(seq);
return (0);
}
int
main(int argc, char *argv[])
{
const char *program=raptor_basename(argv[0]);
raptor_sequence* seq1=raptor_new_sequence(NULL, (raptor_sequence_print_handler*)raptor_sequence_print_string);
raptor_sequence* seq2=raptor_new_sequence(NULL, (raptor_sequence_print_handler*)raptor_sequence_print_string);
char *s;
int i;
if(raptor_sequence_pop(seq1) || raptor_sequence_unshift(seq1)) {
fprintf(stderr, "%s: should not be able to pop/unshift from an empty sequence\n", program);
exit(1);
}
raptor_sequence_set_at(seq1, 0, (void*)"first");
raptor_sequence_push(seq1, (void*)"third");
raptor_sequence_shift(seq1, (void*)"second");
s=(char*)raptor_sequence_get_at(seq1, 0);
assert_match_string(raptor_sequence_get_at, s, "second");
s=(char*)raptor_sequence_get_at(seq1, 1);
assert_match_string(raptor_sequence_get_at, s, "first");
s=(char*)raptor_sequence_get_at(seq1, 2);
assert_match_string(raptor_sequence_get_at, s, "third");
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 3);
fprintf(stderr, "%s: sequence after additions: ", program);
raptor_sequence_print(seq1, stderr);
fputc('\n', stderr);
/* now made alphabetical i.e. first, second, third */
raptor_sequence_sort(seq1, raptor_compare_strings);
fprintf(stderr, "%s: sequence after sort: ", program);
raptor_sequence_print(seq1, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_pop(seq1);
assert_match_string(raptor_sequence_get_at, s, "third");
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 2);
fprintf(stderr, "%s: sequence after pop: ", program);
raptor_sequence_print(seq1, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_unshift(seq1);
assert_match_string(raptor_sequence_get_at, s, "first");
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 1);
fprintf(stderr, "%s: sequence after unshift: ", program);
raptor_sequence_print(seq1, stderr);
fputc('\n', stderr);
s=(char*)raptor_sequence_get_at(seq1, 0);
assert_match_string(raptor_sequence_get_at, s, "second");
raptor_sequence_push(seq2, (void*)"first.2");
if(raptor_sequence_join(seq2, seq1)) {
fprintf(stderr, "%s: raptor_sequence_join failed\n", program);
exit(1);
}
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 0);
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq2), 2);
raptor_free_sequence(seq1);
raptor_free_sequence(seq2);
/* test sequence growing */
seq1=raptor_new_sequence(NULL, (raptor_sequence_print_handler*)raptor_sequence_print_string);
for(i=0; i<100; i++)
if(raptor_sequence_shift(seq1, (void*)"foo")) {
fprintf(stderr, "%s: raptor_sequence_shift failed\n", program);
exit(1);
}
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 100);
for(i=0; i<100; i++)
raptor_sequence_unshift(seq1);
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 0);
raptor_free_sequence(seq1);
seq1=raptor_new_sequence(NULL, (raptor_sequence_print_handler*)raptor_sequence_print_string);
for(i=0; i<100; i++)
if(raptor_sequence_push(seq1, (void*)"foo")) {
fprintf(stderr, "%s: raptor_sequence_push failed\n", program);
exit(1);
}
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 100);
for(i=0; i<100; i++)
raptor_sequence_pop(seq1);
assert_match_int(raptor_sequence_size, raptor_sequence_size(seq1), 0);
raptor_free_sequence(seq1);
return (0);
}
