static rasqal_row*
rasqal_join_rowsource_read_row(rasqal_rowsource* rowsource, void *user_data)
{
rasqal_join_rowsource_context* con;
rasqal_row* row = NULL;
rasqal_query *query = rowsource->query;
con = (rasqal_join_rowsource_context*)user_data;
if(con->failed || con->state == JS_FINISHED)
return NULL;
while(1) {
rasqal_row *right_row;
int bresult = 1;
int compatible = 1;
if(con->state == JS_START) {
/* start / re-start left */
if(con->left_row)
rasqal_free_row(con->left_row);
con->left_row = rasqal_rowsource_read_row(con->left);
#ifdef RASQAL_DEBUG
RASQAL_DEBUG2("rowsource %p read left row : ", rowsource);
if(con->left_row)
rasqal_row_print(con->left_row, stderr);
else
fputs("NONE", stderr);
fputs("\n", stderr);
#endif
con->state = JS_INIT_RIGHT;
}
if(con->state == JS_INIT_RIGHT) {
/* start right */
if(!con->left_row) {
con->state = JS_FINISHED;
return NULL;
}
con->right_rows_joined_count = 0;
rasqal_rowsource_reset(con->right);
}
right_row = rasqal_rowsource_read_row(con->right);
#ifdef RASQAL_DEBUG
RASQAL_DEBUG2("rowsource %p read right row : ", rowsource);
if(right_row)
rasqal_row_print(right_row, stderr);
else
fputs("NONE", stderr);
fputs("\n", stderr);
#endif
if(!right_row && con->state == JS_READ_RIGHT) {
/* right has finished */
/* restart left */
con->state = JS_START;
/* if all right table returned no bindings, return left row */
if(!con->right_rows_joined_count) {
/* otherwise return LEFT or RIGHT row only */
if(con->join_type == RASQAL_JOIN_TYPE_LEFT) {
/* LEFT JOIN - add left row if expr fails or not compatible */
if(con->left_row) {
con->right_rows_joined_count++;
row = rasqal_join_rowsource_build_merged_row(rowsource, con, NULL);
break;
}
}
}
/* restart left by continuing the loop */
continue;
}
/* state is always JS_READ_RIGHT at this point */
con->state = JS_READ_RIGHT;
/* now may have both left and right rows so compute compatibility */
if(right_row) {
compatible = rasqal_row_compatible_check(con->rc_map,
con->left_row, right_row);
RASQAL_DEBUG2("join rows compatible: %s\n", compatible ? "YES" : "NO");
}
if(con->constant_join_condition >= 0) {
/* Get constant join expression value */
bresult = con->constant_join_condition;
} else if(con->expr) {
/* Check join expression if present */
rasqal_literal *result;
int error = 0;
result = rasqal_expression_evaluate2(con->expr, query->eval_context,
&error);
#ifdef RASQAL_DEBUG
RASQAL_DEBUG1("join expression result: ");
if(error)
fputs("type error", DEBUG_FH);
else
rasqal_literal_print(result, DEBUG_FH);
fputc('\n', DEBUG_FH);
#endif
if(error) {
bresult = 0;
} else {
error = 0;
bresult = rasqal_literal_as_boolean(result, &error);
#ifdef RASQAL_DEBUG
if(error)
RASQAL_DEBUG1("filter boolean expression returned error\n");
else
RASQAL_DEBUG2("filter boolean expression result: %d\n", bresult);
#endif
rasqal_free_literal(result);
}
}
if(con->join_type == RASQAL_JOIN_TYPE_NATURAL) {
/* found a row if compatible and constraint matches */
if(compatible && bresult && right_row) {
con->right_rows_joined_count++;
/* consumes right_row */
row = rasqal_join_rowsource_build_merged_row(rowsource, con, right_row);
break;
}
} else if(con->join_type == RASQAL_JOIN_TYPE_LEFT) {
/*
* { merge(mu1, mu2) | mu1 in Omega1 and mu2 in Omega2, and mu1
* and mu2 are compatible and expr(merge(mu1, mu2)) is true }
*/
if(compatible && bresult) {
con->right_rows_joined_count++;
/* No constraint OR constraint & compatible so return merged row */
/* Compute row only now it is known to be needed (consumes right_row) */
row = rasqal_join_rowsource_build_merged_row(rowsource, con, right_row);
break;
}
#if 0
/*
* { mu1 | mu1 in Omega1 and mu2 in Omega2, and mu1 and mu2 are
* not compatible }
*/
if(!compatible) {
/* otherwise return LEFT or RIGHT row only */
if(con->join_type == RASQAL_JOIN_TYPE_LEFT) {
/* LEFT JOIN - add left row if expr fails or not compatible */
if(con->left_row) {
con->right_rows_joined_count++;
row = rasqal_join_rowsource_build_merged_row(rowsource, con, NULL);
if(right_row)
rasqal_free_row(right_row);
break;
}
}
}
#endif
/*
* { mu1 | mu1 in Omega1 and mu2 in Omega2, and mu1 and mu2 are
* compatible and for all mu2, expr(merge(mu1, mu2)) is false }
*/
/* The above is handled using check for
* !con->right_rows_joined_count earlier, to generate a row
* once.
*/
} /* end if LEFT JOIN */
if(right_row)
rasqal_free_row(right_row);
} /* end while */
if(row) {
rasqal_row_set_rowsource(row, rowsource);
row->offset = con->offset++;
rasqal_row_bind_variables(row, rowsource->query->vars_table);
}
return row;
}
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;
}
static int
rasqal_groupby_rowsource_process(rasqal_rowsource* rowsource,
rasqal_groupby_rowsource_context* con)
{
/* already processed */
if(con->processed)
return 0;
con->processed = 1;
/* Empty expression list - no need to read rows */
if(!con->expr_seq || !con->expr_seq_size) {
con->group_id++;
return 0;
}
con->tree = raptor_new_avltree(rasqal_rowsource_groupby_literal_sequence_compare,
(raptor_data_free_handler)rasqal_free_groupby_tree_node,
/* flags */ 0);
if(!con->tree)
return 1;
raptor_avltree_set_print_handler(con->tree,
rasqal_rowsource_groupby_tree_print_node);
while(1) {
rasqal_row* row;
row = rasqal_rowsource_read_row(con->rowsource);
if(!row)
break;
rasqal_row_bind_variables(row, rowsource->query->vars_table);
if(con->expr_seq) {
raptor_sequence* literal_seq;
rasqal_groupby_tree_node key;
rasqal_groupby_tree_node* node;
literal_seq = rasqal_expression_sequence_evaluate(rowsource->query,
con->expr_seq,
/* ignore_errors */ 0,
/* literal_seq */ NULL,
/* error_p */ NULL);
if(!literal_seq) {
/* FIXME - what to do on errors? */
continue;
}
memset(&key, '\0', sizeof(key));
key.con = con;
key.literals = literal_seq;
node = (rasqal_groupby_tree_node*)raptor_avltree_search(con->tree, &key);
if(!node) {
/* New Group */
node = (rasqal_groupby_tree_node*)RASQAL_CALLOC(rasqal_groupby_tree_node, sizeof(*node), 1);
if(!node) {
raptor_free_sequence(literal_seq);
return 1;
}
node->con = con;
node->group_id = ++con->group_id;
/* node now owns literal_seq */
node->literals = literal_seq;
#ifdef HAVE_RAPTOR2_API
node->rows = raptor_new_sequence((raptor_data_free_handler)rasqal_free_row, (raptor_data_print_handler)rasqal_row_print);
#else
node->rows = raptor_new_sequence((raptor_sequence_free_handler*)rasqal_free_row, (raptor_sequence_print_handler*)rasqal_row_print);
#endif
if(!node->rows) {
rasqal_free_groupby_tree_node(node);
return 1;
}
/* after this, node is owned by con->tree */
raptor_avltree_add(con->tree, node);
} else
raptor_free_sequence(literal_seq);
row->group_id = node->group_id;
/* after this, node owns the row */
raptor_sequence_push(node->rows, row);
}
}
#ifdef RASQAL_DEBUG
if(con->tree) {
fputs("Grouping ", DEBUG_FH);
raptor_avltree_print(con->tree, DEBUG_FH);
fputs("\n", DEBUG_FH);
}
#endif
con->group_iterator = raptor_new_avltree_iterator(con->tree,
NULL, NULL,
1);
con->group_row_index = 0;
con->offset = 0;
return 0;
}