static rasqal_row*
rasqal_empty_rowsource_read_row(rasqal_rowsource* rowsource, void *user_data)
{
rasqal_empty_rowsource_context* con;
rasqal_row* row = NULL;
con = (rasqal_empty_rowsource_context*)user_data;
if(!con->count++)
row = rasqal_new_row(rowsource);
return row;
}
static raptor_sequence*
rasqal_empty_rowsource_read_all_rows(rasqal_rowsource* rowsource,
void *user_data)
{
/* rasqal_empty_rowsource_context* con;
con = (rasqal_empty_rowsource_context*)user_data; */
raptor_sequence *seq;
seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_row,
(raptor_data_print_handler)rasqal_row_print);
if(seq) {
rasqal_row* row = rasqal_new_row(rowsource);
raptor_sequence_push(seq, row);
}
return seq;
}
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 void
rasqal_sparql_xml_sax2_start_element_handler(void *user_data,
raptor_xml_element *xml_element)
{
rasqal_rowsource_sparql_xml_context* con;
int i;
raptor_qname* name;
rasqal_sparql_xml_read_state state=STATE_unknown;
int attr_count;
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++;
}
#ifdef TRACE_XML
if(con->trace) {
pad(stderr, con->depth);
fprintf(stderr, "Element %s (%d)\n", raptor_qname_get_local_name(name),
state);
}
#endif
attr_count=raptor_xml_element_get_attributes_count(xml_element);
con->name=NULL;
con->datatype=NULL;
con->language=NULL;
if(attr_count > 0) {
raptor_qname** attrs=raptor_xml_element_get_attributes(xml_element);
for(i=0; i < attr_count; i++) {
#ifdef TRACE_XML
if(con->trace) {
pad(stderr, con->depth+1);
fprintf(stderr, "Attribute %s='%s'\n",
raptor_qname_get_local_name(attrs[i]),
raptor_qname_get_value(attrs[i]));
}
#endif
if(!strcmp((const char*)raptor_qname_get_local_name(attrs[i]),
"name"))
con->name=(const char*)raptor_qname_get_counted_value(attrs[i],
&con->name_length);
else if(!strcmp((const char*)raptor_qname_get_local_name(attrs[i]),
"datatype"))
con->datatype=(const char*)raptor_qname_get_value(attrs[i]);
}
}
if(raptor_xml_element_get_language(xml_element)) {
con->language=(const char*)raptor_xml_element_get_language(xml_element);
#ifdef TRACE_XML
if(con->trace) {
pad(stderr, con->depth+1);
fprintf(stderr, "xml:lang '%s'\n", con->language);
}
#endif
}
switch(state) {
case STATE_variable:
if(con->name) {
unsigned char* var_name;
rasqal_variable *v;
var_name = (unsigned char*)RASQAL_MALLOC(cstring, con->name_length+1);
memcpy(var_name, con->name, con->name_length + 1);
v = rasqal_variables_table_add(con->vars_table,
RASQAL_VARIABLE_TYPE_NORMAL,
var_name, NULL);
if(v)
rasqal_rowsource_add_variable(con->rowsource, v);
}
break;
case STATE_result:
if(1) {
con->row = rasqal_new_row(con->rowsource);
RASQAL_DEBUG2("Made new row %d\n", con->offset);
con->offset++;
}
break;
case STATE_binding:
con->result_offset = rasqal_rowsource_get_variable_offset_by_name(con->rowsource, (const unsigned char*)con->name);
break;
case STATE_sparql:
case STATE_head:
case STATE_results:
case STATE_literal:
case STATE_bnode:
case STATE_uri:
case STATE_unknown:
default:
break;
}
con->depth++;
}