/** * rasqal_row_bind_variables: * @row: Result row * @vars_table: Variables table * * INTERNAL - Bind the variable table vars withvalues in the row * * Return value: non-0 on failure */ int rasqal_row_bind_variables(rasqal_row* row, rasqal_variables_table* vars_table) { int i; for(i = 0; i < row->size; i++) { rasqal_variable* v; v = rasqal_rowsource_get_variable_by_offset(row->rowsource, i); if(v) { rasqal_literal *value = row->values[i]; if(value) { value = rasqal_new_literal_from_literal(value); if(!value) return 1; } /* it is OK to bind to NULL */ rasqal_variable_set_value(v, value); } } return 0; }
/** * rasqal_row_print: * @row: query result row * @fp: FILE* handle * * INTERNAL - Print a query result row. */ int rasqal_row_print(rasqal_row* row, FILE* fh) { rasqal_rowsource* rowsource = row->rowsource; int i; fputs("result[", fh); for(i = 0; i < row->size; i++) { /* Do not use rasqal_query_results_get_binding_name(row->results, i); * as it does not work for a construct result */ const unsigned char *name = NULL; rasqal_literal *value; if(rowsource) { rasqal_variable* v; v = rasqal_rowsource_get_variable_by_offset(rowsource, i); if(v) name = v->name; } value = row->values[i]; if(i > 0) fputs(", ", fh); if(name) fprintf(fh, "%s=", name); if(value) rasqal_literal_print(value, fh); else fputs("NULL", fh); } if(row->order_size > 0) { fputs(" with ordering values [", fh); for(i = 0; i < row->order_size; i++) { rasqal_literal *value = row->order_values[i]; if(i > 0) fputs(", ", fh); if(value) rasqal_literal_print(value, fh); else fputs("NULL", fh); } fputs("]", fh); } if(row->group_id >= 0) fprintf(fh, " group %d", row->group_id); fprintf(fh, " offset %d]", row->offset); return 0; }
/** * rasqal_rowsource_copy_variables: * @dest_rowsource: destination rowsource to copy into * @src_rowsource: source rowsource to copy from * * INTERNAL - Copy a variables projection from one rowsource to another * * This adds new variables from @src_rowsource to the * @dest_rowsource, it does not add duplicates. * * Return value: 0 on success, non-0 on failure **/ int rasqal_rowsource_copy_variables(rasqal_rowsource *dest_rowsource, rasqal_rowsource *src_rowsource) { int i; for(i = 0; i < src_rowsource->size; i++) { rasqal_variable* v; v = rasqal_rowsource_get_variable_by_offset(src_rowsource, i); if(rasqal_rowsource_add_variable(dest_rowsource, v) < 0) return 1; } return 0; }
static int rasqal_join_rowsource_ensure_variables(rasqal_rowsource* rowsource, void *user_data) { rasqal_join_rowsource_context* con; int map_size; int i; con = (rasqal_join_rowsource_context*)user_data; if(rasqal_rowsource_ensure_variables(con->left)) return 1; if(rasqal_rowsource_ensure_variables(con->right)) return 1; map_size = rasqal_rowsource_get_size(con->right); con->right_map = RASQAL_MALLOC(int*, RASQAL_GOOD_CAST(size_t, sizeof(int) * RASQAL_GOOD_CAST(size_t, map_size))); if(!con->right_map) return 1; rowsource->size = 0; /* copy in variables from left rowsource */ if(rasqal_rowsource_copy_variables(rowsource, con->left)) return 1; /* add any new variables not already seen from right rowsource */ for(i = 0; i < map_size; i++) { rasqal_variable* v; int offset; v = rasqal_rowsource_get_variable_by_offset(con->right, i); if(!v) break; offset = rasqal_rowsource_add_variable(rowsource, v); if(offset < 0) return 1; con->right_map[i] = offset; } return 0; }
/** * rasqal_rowsource_copy_variables: * @dest_rowsource: destination rowsource to copy into * @src_rowsource: source rowsource to copy from * * INTERNAL - Copy a variables projection from one rowsource to another * * This adds new variables from @src_rowsource to the * @dest_rowsource, it does not add duplicates. * * Return value: 0 on success, non-0 on failure **/ int rasqal_rowsource_copy_variables(rasqal_rowsource *dest_rowsource, rasqal_rowsource *src_rowsource) { int i; for(i = 0; i < src_rowsource->size; i++) { rasqal_variable* v; v = rasqal_rowsource_get_variable_by_offset(src_rowsource, i); if(!v) { RASQAL_DEBUG5("%s src rowsource %p failed to return variable at offset %d, size %d\n", src_rowsource->handler->name, src_rowsource, i, src_rowsource->size); return 1; } if(rasqal_rowsource_add_variable(dest_rowsource, v) < 0) return 1; } return 0; }
static void rasqal_rowsource_print_header(rasqal_rowsource* rowsource, FILE* fh) { int i; fputs("variables: ", fh); for(i = 0; i < rowsource->size; i++) { rasqal_variable* v; const unsigned char *name = NULL; v = rasqal_rowsource_get_variable_by_offset(rowsource, i); if(v) name = v->name; if(i > 0) fputs(", ", fh); if(name) fputs((const char*)name, fh); else fputs("NULL", fh); } fputs("\n", fh); }
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[]) { 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; }
int main(int argc, char *argv[]) { const char *program = rasqal_basename(argv[0]); rasqal_rowsource *rowsource = NULL; rasqal_rowsource *left_rs = NULL; rasqal_rowsource *right_rs = NULL; rasqal_world* world = NULL; rasqal_query* query = NULL; int count; raptor_sequence* seq = NULL; int failures = 0; rasqal_variables_table* vt; int size; int expected_size = EXPECTED_COLUMNS_COUNT; int i; raptor_sequence* vars_seq = NULL; int test_count; world = rasqal_new_world(); rasqal_world_open(world); query = rasqal_new_query(world, "sparql", NULL); vt = query->vars_table; for(test_count = 0; test_count < JOIN_TESTS_COUNT; test_count++) { rasqal_join_type join_type = join_test_config[test_count].join_type; int expected_count = join_test_config[test_count].expected; int vars_count; fprintf(stderr, "%s: test #%d join type %d\n", program, test_count, RASQAL_GOOD_CAST(int, join_type)); /* 2 variables and 3 rows */ vars_count = 2; seq = rasqal_new_row_sequence(world, vt, join_1_data_2x3_rows, vars_count, &vars_seq); if(!seq) { fprintf(stderr, "%s: failed to create left sequence of %d vars\n", program, vars_count); failures++; goto tidy; } left_rs = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq); if(!left_rs) { fprintf(stderr, "%s: failed to create left rowsource\n", program); failures++; goto tidy; } /* vars_seq and seq are now owned by left_rs */ vars_seq = seq = NULL; /* 3 variables and 2 rows */ vars_count = 3; seq = rasqal_new_row_sequence(world, vt, join_2_data_3x2_rows, vars_count, &vars_seq); if(!seq) { fprintf(stderr, "%s: failed to create right sequence of %d rows\n", program, vars_count); failures++; goto tidy; } right_rs = rasqal_new_rowsequence_rowsource(world, query, vt, seq, vars_seq); if(!right_rs) { fprintf(stderr, "%s: failed to create right rowsource\n", program); failures++; goto tidy; } /* vars_seq and seq are now owned by right_rs */ vars_seq = seq = NULL; rowsource = rasqal_new_join_rowsource(world, query, left_rs, right_rs, join_type, NULL); if(!rowsource) { fprintf(stderr, "%s: failed to create join rowsource\n", program); failures++; goto tidy; } /* left_rs and right_rs are now owned by rowsource */ left_rs = right_rs = NULL; seq = rasqal_rowsource_read_all_rows(rowsource); if(!seq) { fprintf(stderr, "%s: read_rows returned a NULL seq for a join rowsource\n", program); failures++; goto tidy; } count = raptor_sequence_size(seq); if(count != expected_count) { fprintf(stderr, "%s: read_rows returned %d rows for a join rowsource, expected %d\n", program, count, expected_count); failures++; goto tidy; } size = rasqal_rowsource_get_size(rowsource); if(size != expected_size) { fprintf(stderr, "%s: read_rows returned %d columns (variables) for a join rowsource, expected %d\n", program, size, expected_size); failures++; goto tidy; } for(i = 0; i < expected_size; i++) { rasqal_variable* v; const char* name = NULL; const char *expected_name = join_result_vars[i]; v = rasqal_rowsource_get_variable_by_offset(rowsource, i); if(!v) { fprintf(stderr, "%s: read_rows had NULL column (variable) #%d expected %s\n", program, i, expected_name); failures++; goto tidy; } name = RASQAL_GOOD_CAST(const char*, v->name); if(strcmp(name, expected_name)) { fprintf(stderr, "%s: read_rows returned column (variable) #%d %s but expected %s\n", program, i, name, expected_name); failures++; goto tidy; } } #ifdef RASQAL_DEBUG rasqal_rowsource_print_row_sequence(rowsource, seq, DEBUG_FH); #endif raptor_free_sequence(seq); seq = NULL; rasqal_free_rowsource(rowsource); rowsource = NULL; /* end test_count loop */ } tidy: if(seq) raptor_free_sequence(seq); if(left_rs) rasqal_free_rowsource(left_rs); if(right_rs) rasqal_free_rowsource(right_rs); if(rowsource) rasqal_free_rowsource(rowsource); if(query) rasqal_free_query(query); if(world) rasqal_free_world(world); return failures; }