static rasqal_expression*
make_test_expr(rasqal_world* world,
raptor_sequence* expr_vars_seq,
rasqal_op op)
{
if(op == RASQAL_EXPR_MAX ||
op == RASQAL_EXPR_MIN ||
op == RASQAL_EXPR_SUM ||
op == RASQAL_EXPR_AVG ||
op == RASQAL_EXPR_SAMPLE) {
rasqal_expression* arg1;
arg1 = raptor_sequence_delete_at(expr_vars_seq, 0);
raptor_free_sequence(expr_vars_seq);
return rasqal_new_aggregate_function_expression(world, op,
arg1,
/* params */ NULL,
/* flags */ 0);
}
if(op == RASQAL_EXPR_GROUP_CONCAT) {
return rasqal_new_group_concat_expression(world,
/* flags */ 0,
expr_vars_seq,
/* separator */ NULL);
}
return NULL;
}
static rasqal_row*
rasqal_groupby_rowsource_read_row(rasqal_rowsource* rowsource, void *user_data)
{
rasqal_groupby_rowsource_context* con;
rasqal_row *row = NULL;
con = (rasqal_groupby_rowsource_context*)user_data;
/* ensure we have stored grouped rows */
if(rasqal_groupby_rowsource_process(rowsource, con))
return NULL;
if(con->tree) {
rasqal_groupby_tree_node* node = NULL;
/* Rows were grouped so iterate through grouped rows */
while(1) {
node = (rasqal_groupby_tree_node*)raptor_avltree_iterator_get(con->group_iterator);
if(!node) {
/* No more nodes. finished last group and last row */
raptor_free_avltree_iterator(con->group_iterator);
con->group_iterator = NULL;
raptor_free_avltree(con->tree);
con->tree = NULL;
/* row = NULL is already set */
break;
}
/* removes row from sequence and this code now owns the reference */
row = (rasqal_row*)raptor_sequence_delete_at(node->rows,
con->group_row_index++);
if(row)
break;
/* End of sequence so reset row sequence index and advance iterator */
con->group_row_index = 0;
if(raptor_avltree_iterator_next(con->group_iterator))
break;
}
if(node && row)
row->group_id = node->group_id;
} else {
/* just pass rows through all in one group */
row = rasqal_rowsource_read_row(con->rowsource);
if(row)
row->group_id = con->group_id;
}
if(row)
row->offset = con->offset++;
return row;
}
/**
* rasqal_rowsource_read_row:
* @rowsource: rasqal rowsource
*
* Read a query result row from the rowsource.
*
* If a row is returned, it is owned by the caller.
*
* Return value: row or NULL when no more rows are available
**/
rasqal_row*
rasqal_rowsource_read_row(rasqal_rowsource *rowsource)
{
rasqal_row* row = NULL;
if(rowsource->finished)
return NULL;
if(rasqal_rowsource_ensure_variables(rowsource))
return NULL;
if(rowsource->handler->read_row)
row = rowsource->handler->read_row(rowsource, rowsource->user_data);
else {
if(!rowsource->rows_sequence) {
rowsource->rows_sequence = rasqal_rowsource_read_all_rows(rowsource);
rowsource->offset = 0;
}
if(rowsource->rows_sequence)
/* remove and return row from sequence at offset */
row = (rasqal_row*)raptor_sequence_delete_at(rowsource->rows_sequence,
rowsource->offset++);
}
if(!row)
rowsource->finished = 1;
else {
rowsource->count++;
/* Generate a group around all rows if there are no groups returned */
if(rowsource->generate_group && row->group_id < 0)
row->group_id = 0;
}
#ifdef RASQAL_DEBUG
RASQAL_DEBUG3("%s rowsource %p read row: ", rowsource->handler->name,
rowsource);
if(row)
rasqal_row_print(row, stderr);
else
fputs("NONE", stderr);
fputs("\n", stderr);
#endif
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;
}
