/** * 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; }
static void print_bindings_result_simple(rasqal_query_results *results, FILE* output, int quiet) { while(!rasqal_query_results_finished(results)) { int i; fputs("result: [", output); for(i = 0; i < rasqal_query_results_get_bindings_count(results); i++) { const unsigned char *name; rasqal_literal *value; name = rasqal_query_results_get_binding_name(results, i); value = rasqal_query_results_get_binding_value(results, i); if(i > 0) fputs(", ", output); fprintf(output, "%s=", name); if(value) rasqal_literal_print(value, output); else fputs("NULL", output); } fputs("]\n", output); rasqal_query_results_next(results); } if(!quiet) fprintf(stderr, "%s: Query returned %d results\n", program, rasqal_query_results_get_count(results)); }
/** * rasqal_variable_print: * @v: the #rasqal_variable object * @fh: the FILE* handle to print to * * Print a Rasqal variable in a debug format. * * The print debug format may change in any release. * * Return value: non-0 on failure **/ int rasqal_variable_print(rasqal_variable* v, FILE* fh) { if(v->type == RASQAL_VARIABLE_TYPE_ANONYMOUS) fprintf(fh, "anon-variable(%s", v->name); else fprintf(fh, "variable(%s", v->name); if(v->expression) { fputc('=', fh); rasqal_expression_print(v->expression, fh); } if(v->value) { fputc('=', fh); rasqal_literal_print(v->value, fh); } #ifdef RASQAL_DEBUG_VARIABLE_USAGE fprintf(fh, "[%d]", v->usage); #endif fputc(')', fh); return 0; }
/** * rasqal_triple_print: * @t: #rasqal_triple object. * @fh: The FILE* handle to print to. * * Print a Rasqal triple in a debug format. * * The print debug format may change in any release. * * Return value: non-0 on failure **/ int rasqal_triple_print(rasqal_triple* t, FILE* fh) { RASQAL_ASSERT_OBJECT_POINTER_RETURN_VALUE(t, rasqal_triple, 1); RASQAL_ASSERT_OBJECT_POINTER_RETURN_VALUE(fh, FILE*, 1); fputs("triple(", fh); rasqal_literal_print(t->subject, fh); fputs(", ", fh); rasqal_literal_print(t->predicate, fh); fputs(", ", fh); rasqal_literal_print(t->object, fh); fputc(')', fh); if(t->origin) { fputs(" with origin(", fh); rasqal_literal_print(t->origin, fh); fputc(')', fh); } return 0; }
/** * rasqal_variable_set_value: * @v: the #rasqal_variable object * @l: the #rasqal_literal value to set (or NULL) * * Set the value of a Rasqal variable. * * The variable value is an input parameter and is copied in, not shared. * If the variable value is NULL, any existing value is deleted. * **/ void rasqal_variable_set_value(rasqal_variable* v, rasqal_literal* l) { if(v->value) rasqal_free_literal(v->value); v->value = l; #ifdef RASQAL_DEBUG if(!v->name) RASQAL_FATAL1("variable has no name"); RASQAL_DEBUG2("setting variable %s to value ", v->name); rasqal_literal_print(v->value, stderr); fputc('\n', stderr); #endif }
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; }
void rasqal_cmdline_print_bindings_results_simple(const char* program, rasqal_query_results *results, FILE* output, int quiet, int count) { if(!quiet) fprintf(stderr, "%s: Query has a variable bindings result\n", program); while(!rasqal_query_results_finished(results)) { if(!count) { int i; fputs("row: [", output); for(i = 0; i < rasqal_query_results_get_bindings_count(results); i++) { const unsigned char *name; rasqal_literal *value; name = rasqal_query_results_get_binding_name(results, i); value = rasqal_query_results_get_binding_value(results, i); if(i > 0) fputs(", ", output); fprintf(output, "%s=", name); rasqal_literal_print(value, output); } fputs("]\n", output); } rasqal_query_results_next(results); } if(!quiet) fprintf(stderr, "%s: Query returned %d results\n", program, rasqal_query_results_get_count(results)); }
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[]) { #if 0 raptor_uri *xsd_uri; raptor_uri *dateTime_uri; rasqal_literal *l1, *l2; int fn_i; raptor_uri* fn_uri; const unsigned char *fn_name; rasqal_extension_fn fn; raptor_sequence *fn_args; char *error; rasqal_literal *fn_result; rasqal_world *world; world = rasqal_new_world(); if(!world || rasqal_world_open(world)) { fprintf(stderr, "%s: rasqal_world init failed\n", program); return(1); } xsd_uri = raptor_new_uri(raptor_xmlschema_datatypes_namespace_uri); dateTime_uri = raptor_new_uri_from_uri_local_name(xsd_uri, (const unsigned char*)"dateTime"); rasqal_init_datatypes(); fn_args = raptor_new_sequence((raptor_sequence_free_handler*)rasqal_free_literal, (raptor_sequence_print_handler*)rasqal_literal_print); l1 = rasqal_new_string_literal((unsigned char*)strdup("2004-05-04"), NULL, raptor_uri_copy(dateTime_uri), NULL); raptor_sequence_push(fn_args, l1); l2 = rasqal_new_string_literal((unsigned char*)strdup("2003-01-02"), NULL, raptor_uri_copy(dateTime_uri), NULL); raptor_sequence_push(fn_args, l2); fn_i = 0; fn_name = rasqal_xsd_datatype_fns[fn_i].name; fn = rasqal_xsd_datatype_fns[fn_i].fn; fn_uri = rasqal_xsd_datatype_fns[fn_i].uri; error = NULL; fn_result = fn(fn_uri, fn_args, &error); raptor_free_sequence(fn_args); if(!fn_result) { if(error) fprintf(stderr, "function %s failed with error %s\n", fn_name, error); else fprintf(stderr, "function %s unknown error\n", fn_name); } else { fprintf(stderr, "function %s returned result: ", fn_name); rasqal_literal_print(fn_result, stderr); fputc('\n', stderr); } if(fn_result) rasqal_free_literal(fn_result); rasqal_finish_datatypes(); raptor_free_uri(xsd_uri); raptor_free_uri(dateTime_uri); rasqal_free_world(world); #endif return 0; }
static int rasqal_join_rowsource_init(rasqal_rowsource* rowsource, void *user_data) { rasqal_join_rowsource_context* con; rasqal_variables_table* vars_table; con = (rasqal_join_rowsource_context*)user_data; con->failed = 0; con->state = JS_START; con->constant_join_condition = -1; /* If join condition is a constant - optimize it away */ if(con->expr && rasqal_expression_is_constant(con->expr)) { rasqal_query *query = rowsource->query; rasqal_literal* result; int bresult; int error = 0; result = rasqal_expression_evaluate2(con->expr, query->eval_context, &error); #ifdef RASQAL_DEBUG RASQAL_DEBUG1("join expression condition is constant: "); 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("join boolean expression returned error\n"); else RASQAL_DEBUG2("join boolean expression result: %d\n", bresult); #endif rasqal_free_literal(result); } /* free expression always */ rasqal_free_expression(con->expr); con->expr = NULL; if(con->join_type == RASQAL_JOIN_TYPE_NATURAL) { if(!bresult) { /* Constraint is always false so row source is finished */ con->state = JS_FINISHED; } /* otherwise always true so no need to evaluate on each row * and deleting con->expr will handle that */ } con->constant_join_condition = bresult; } rasqal_rowsource_set_requirements(con->left, RASQAL_ROWSOURCE_REQUIRE_RESET); rasqal_rowsource_set_requirements(con->right, RASQAL_ROWSOURCE_REQUIRE_RESET); vars_table = con->left->vars_table; con->rc_map = rasqal_new_row_compatible(vars_table, con->left, con->right); if(!con->rc_map) return -1; #ifdef RASQAL_DEBUG RASQAL_DEBUG2("rowsource %p ", rowsource); rasqal_print_row_compatible(stderr, con->rc_map); #endif return 0; }
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; }
/** * rasqal_expression_evaluate2: * @e: The expression to evaluate. * @eval_context: expression context * @error_p: pointer to error return flag * * Evaluate a #rasqal_expression tree in the context of a * #rasqal_evaluation_context to give a #rasqal_literal result or error. * * Return value: a #rasqal_literal value or NULL (a valid value). @error_p is set to non-0 on failure. **/ rasqal_literal* rasqal_expression_evaluate2(rasqal_expression* e, rasqal_evaluation_context* eval_context, int *error_p) { rasqal_world *world; int flags; rasqal_literal* result = NULL; rasqal_literal *l1; rasqal_literal *l2; /* pack vars from different switch cases in unions to save some stack space */ union { struct { int e1; int e2; } errs; struct { int dummy_do_not_mask_e; int free_literal; } flags; int e; } errs; union { struct { int b1; int b2; } bools; int b; int i; raptor_uri *dt_uri; const unsigned char *s; unsigned char *new_s; rasqal_variable *v; rasqal_expression *e; struct { void *dummy_do_not_mask; int found; } flags; rasqal_xsd_datetime* dt; struct timeval *tv; raptor_stringbuffer* sb; } vars; RASQAL_ASSERT_OBJECT_POINTER_RETURN_VALUE(e, rasqal_expression, NULL); RASQAL_ASSERT_OBJECT_POINTER_RETURN_VALUE(eval_context, rasqal_evaluation_context, NULL); RASQAL_ASSERT_OBJECT_POINTER_RETURN_VALUE(error_p, intp, NULL); world = eval_context->world; flags = eval_context->flags; errs.e = 0; #ifdef RASQAL_DEBUG RASQAL_DEBUG2("evaluating expression %p: ", e); rasqal_expression_print(e, stderr); fprintf(stderr, "\n"); #endif switch(e->op) { case RASQAL_EXPR_AND: errs.errs.e1 = 0; l1 = rasqal_expression_evaluate2(e->arg1, eval_context, &errs.errs.e1); if(errs.errs.e1) { vars.bools.b1 = 0; } else { vars.bools.b1 = rasqal_literal_as_boolean(l1, &errs.errs.e1); rasqal_free_literal(l1); } errs.errs.e2 = 0; l1 = rasqal_expression_evaluate2(e->arg2, eval_context, &errs.errs.e2); if(errs.errs.e2) { vars.bools.b2 = 0; } else { vars.bools.b2 = rasqal_literal_as_boolean(l1, &errs.errs.e2); rasqal_free_literal(l1); } /* See http://www.w3.org/TR/2005/WD-rdf-sparql-query-20051123/#truthTable */ if(!errs.errs.e1 && !errs.errs.e2) { /* No type error, answer is A && B */ vars.b = vars.bools.b1 && vars.bools.b2; /* don't need b1,b2 anymore */ } else { if((!vars.bools.b1 && errs.errs.e2) || (errs.errs.e1 && vars.bools.b2)) /* F && E => F. E && F => F. */ vars.b = 0; else /* Otherwise E */ goto failed; } result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_OR: errs.errs.e1 = 0; l1 = rasqal_expression_evaluate2(e->arg1, eval_context, &errs.errs.e1); if(errs.errs.e1) { vars.bools.b1 = 0; } else { vars.bools.b1 = rasqal_literal_as_boolean(l1, &errs.errs.e1); rasqal_free_literal(l1); } errs.errs.e2 = 0; l1 = rasqal_expression_evaluate2(e->arg2, eval_context, &errs.errs.e2); if(errs.errs.e2) { vars.bools.b2 = 0; } else { vars.bools.b2 = rasqal_literal_as_boolean(l1, &errs.errs.e2); rasqal_free_literal(l1); } /* See http://www.w3.org/TR/2005/WD-rdf-sparql-query-20051123/#truthTable */ if(!errs.errs.e1 && !errs.errs.e2) { /* No type error, answer is A || B */ vars.b = vars.bools.b1 || vars.bools.b2; /* don't need b1,b2 anymore */ } else { if((vars.bools.b1 && errs.errs.e2) || (errs.errs.e1 && vars.bools.b2)) /* T || E => T. E || T => T */ vars.b = 1; else /* Otherwise E */ goto failed; } result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_EQ: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } /* FIXME - this should probably be checked at literal creation * time */ if(!rasqal_xsd_datatype_check(l1->type, l1->string, flags) || !rasqal_xsd_datatype_check(l2->type, l2->string, flags)) { RASQAL_DEBUG1("One of the literals was invalid\n"); goto failed; } vars.b = (rasqal_literal_equals_flags(l1, l2, flags, &errs.e) != 0); #if RASQAL_DEBUG > 1 if(errs.e) RASQAL_DEBUG1("rasqal_literal_equals_flags returned: FAILURE\n"); else RASQAL_DEBUG2("rasqal_literal_equals_flags returned: %d\n", vars.b); #endif rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_NEQ: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_not_equals_flags(l1, l2, flags, &errs.e) != 0); #if RASQAL_DEBUG > 1 if(errs.e) RASQAL_DEBUG1("rasqal_literal_not_equals_flags returned: FAILURE\n"); else RASQAL_DEBUG2("rasqal_literal_not_equals_flags returned: %d\n", vars.b); #endif rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_LT: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags, &errs.e) < 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_GT: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags, &errs.e) > 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_LE: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags, &errs.e) <= 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_GE: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags, &errs.e) >= 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_UMINUS: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; result = rasqal_literal_negate(l1, &errs.e); rasqal_free_literal(l1); if(errs.e) goto failed; break; case RASQAL_EXPR_BOUND: result = rasqal_expression_evaluate_bound(e, eval_context, error_p); break; case RASQAL_EXPR_STR: result = rasqal_expression_evaluate_str(e, eval_context, error_p); break; case RASQAL_EXPR_LANG: result = rasqal_expression_evaluate_lang(e, eval_context, error_p); break; case RASQAL_EXPR_LANGMATCHES: result = rasqal_expression_evaluate_langmatches(e, eval_context, error_p); break; case RASQAL_EXPR_DATATYPE: result = rasqal_expression_evaluate_datatype(e, eval_context, error_p); break; case RASQAL_EXPR_ISURI: case RASQAL_EXPR_ISBLANK: case RASQAL_EXPR_ISLITERAL: case RASQAL_EXPR_ISNUMERIC: result = rasqal_expression_evaluate_istype(e, eval_context, error_p); break; case RASQAL_EXPR_PLUS: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } result = rasqal_literal_add(l1, l2, &errs.e); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; break; case RASQAL_EXPR_MINUS: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } result = rasqal_literal_subtract(l1, l2, &errs.e); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; break; case RASQAL_EXPR_STAR: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } result = rasqal_literal_multiply(l1, l2, &errs.e); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; break; case RASQAL_EXPR_SLASH: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } result = rasqal_literal_divide(l1, l2, &errs.e); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; break; case RASQAL_EXPR_REM: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.i = rasqal_literal_as_integer(l2, &errs.errs.e2); /* error if divisor is zero */ if(!vars.i) errs.errs.e2 = 1; else vars.i = rasqal_literal_as_integer(l1, &errs.errs.e1) % vars.i; rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.errs.e1 || errs.errs.e2) goto failed; result = rasqal_new_integer_literal(world, RASQAL_LITERAL_INTEGER, vars.i); break; case RASQAL_EXPR_STR_EQ: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags | RASQAL_COMPARE_NOCASE, &errs.e) == 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_STR_NEQ: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; l2 = rasqal_expression_evaluate2(e->arg2, eval_context, error_p); if(*error_p || !l2) { rasqal_free_literal(l1); goto failed; } vars.b = (rasqal_literal_compare(l1, l2, flags | RASQAL_COMPARE_NOCASE, &errs.e) != 0); rasqal_free_literal(l1); rasqal_free_literal(l2); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_TILDE: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; vars.i= ~ rasqal_literal_as_integer(l1, &errs.e); rasqal_free_literal(l1); if(errs.e) goto failed; result = rasqal_new_integer_literal(world, RASQAL_LITERAL_INTEGER, vars.i); break; case RASQAL_EXPR_BANG: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; vars.b = ! rasqal_literal_as_boolean(l1, &errs.e); rasqal_free_literal(l1); if(errs.e) goto failed; result = rasqal_new_boolean_literal(world, vars.b); break; case RASQAL_EXPR_STR_MATCH: case RASQAL_EXPR_STR_NMATCH: case RASQAL_EXPR_REGEX: result = rasqal_expression_evaluate_strmatch(e, eval_context, error_p); break; case RASQAL_EXPR_LITERAL: /* flatten any literal to a value as soon as possible - this * removes variables from expressions the first time they are seen. * (FLATTEN_LITERAL) */ result = rasqal_new_literal_from_literal(rasqal_literal_value(e->literal)); break; case RASQAL_EXPR_FUNCTION: rasqal_log_warning_simple(world, RASQAL_WARNING_LEVEL_NOT_IMPLEMENTED, eval_context->locator, "No function expressions support at present. Returning false."); result = rasqal_new_boolean_literal(world, 0); break; case RASQAL_EXPR_CAST: l1 = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); if(*error_p || !l1) goto failed; result = rasqal_literal_cast(l1, e->name, flags, &errs.e); rasqal_free_literal(l1); if(errs.e) goto failed; break; case RASQAL_EXPR_ORDER_COND_ASC: case RASQAL_EXPR_ORDER_COND_DESC: case RASQAL_EXPR_GROUP_COND_ASC: case RASQAL_EXPR_GROUP_COND_DESC: result = rasqal_expression_evaluate2(e->arg1, eval_context, error_p); break; case RASQAL_EXPR_COUNT: case RASQAL_EXPR_SUM: case RASQAL_EXPR_AVG: case RASQAL_EXPR_MIN: case RASQAL_EXPR_MAX: case RASQAL_EXPR_SAMPLE: case RASQAL_EXPR_GROUP_CONCAT: rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, eval_context->locator, "Aggregate expressions cannot be evaluated in a general scalar expression."); errs.e = 1; goto failed; break; case RASQAL_EXPR_VARSTAR: /* constants */ break; case RASQAL_EXPR_SAMETERM: result = rasqal_expression_evaluate_sameterm(e, eval_context, error_p); break; case RASQAL_EXPR_CONCAT: result = rasqal_expression_evaluate_concat(e, eval_context, error_p); break; case RASQAL_EXPR_COALESCE: result = rasqal_expression_evaluate_coalesce(e, eval_context, error_p); break; case RASQAL_EXPR_IF: result = rasqal_expression_evaluate_if(e, eval_context, error_p); break; case RASQAL_EXPR_URI: case RASQAL_EXPR_IRI: result = rasqal_expression_evaluate_uri_constructor(e, eval_context, error_p); break; case RASQAL_EXPR_STRLANG: result = rasqal_expression_evaluate_strlang(e, eval_context, error_p); break; case RASQAL_EXPR_STRDT: result = rasqal_expression_evaluate_strdt(e, eval_context, error_p); break; case RASQAL_EXPR_BNODE: result = rasqal_expression_evaluate_bnode_constructor(e, eval_context, error_p); break; case RASQAL_EXPR_IN: result = rasqal_expression_evaluate_in_set(e, eval_context, error_p); break; case RASQAL_EXPR_NOT_IN: result = rasqal_expression_evaluate_in_set(e, eval_context, error_p); break; case RASQAL_EXPR_YEAR: case RASQAL_EXPR_MONTH: case RASQAL_EXPR_DAY: case RASQAL_EXPR_HOURS: case RASQAL_EXPR_MINUTES: case RASQAL_EXPR_SECONDS: result = rasqal_expression_evaluate_datetime_part(e, eval_context, error_p); break; case RASQAL_EXPR_CURRENT_DATETIME: case RASQAL_EXPR_NOW: result = rasqal_expression_evaluate_now(e, eval_context, error_p); break; case RASQAL_EXPR_TO_UNIXTIME: result = rasqal_expression_evaluate_to_unixtime(e, eval_context, error_p); break; case RASQAL_EXPR_FROM_UNIXTIME: result = rasqal_expression_evaluate_from_unixtime(e, eval_context, error_p); break; case RASQAL_EXPR_RAND: result = rasqal_expression_evaluate_rand(e, eval_context, error_p); break; case RASQAL_EXPR_STRLEN: result = rasqal_expression_evaluate_strlen(e, eval_context, error_p); break; case RASQAL_EXPR_UCASE: case RASQAL_EXPR_LCASE: result = rasqal_expression_evaluate_set_case(e, eval_context, error_p); break; case RASQAL_EXPR_STRSTARTS: case RASQAL_EXPR_STRENDS: case RASQAL_EXPR_CONTAINS: result = rasqal_expression_evaluate_str_prefix_suffix(e, eval_context, error_p); break; case RASQAL_EXPR_TIMEZONE: result = rasqal_expression_evaluate_datetime_timezone(e, eval_context, error_p); break; case RASQAL_EXPR_TZ: result = rasqal_expression_evaluate_datetime_tz(e, eval_context, error_p); break; case RASQAL_EXPR_ENCODE_FOR_URI: result = rasqal_expression_evaluate_encode_for_uri(e, eval_context, error_p); break; case RASQAL_EXPR_SUBSTR: result = rasqal_expression_evaluate_substr(e, eval_context, error_p); break; case RASQAL_EXPR_ABS: result = rasqal_expression_evaluate_abs(e, eval_context, error_p); break; case RASQAL_EXPR_ROUND: result = rasqal_expression_evaluate_round(e, eval_context, error_p); break; case RASQAL_EXPR_CEIL: result = rasqal_expression_evaluate_ceil(e, eval_context, error_p); break; case RASQAL_EXPR_FLOOR: result = rasqal_expression_evaluate_floor(e, eval_context, error_p); break; case RASQAL_EXPR_MD5: case RASQAL_EXPR_SHA1: case RASQAL_EXPR_SHA224: case RASQAL_EXPR_SHA256: case RASQAL_EXPR_SHA384: case RASQAL_EXPR_SHA512: result = rasqal_expression_evaluate_digest(e, eval_context, error_p); break; case RASQAL_EXPR_UNKNOWN: default: RASQAL_FATAL3("Unknown operation %s (%d)", rasqal_expression_op_label(e->op), e->op); } got_result: #ifdef RASQAL_DEBUG RASQAL_DEBUG2("result of %p: ", e); rasqal_expression_print(e, stderr); fputs( ": ", stderr); if(*error_p) fputs("FAILURE",stderr); else rasqal_literal_print(result, stderr); fputc('\n', stderr); #endif return result; failed: *error_p = 1; if(result) { rasqal_free_literal(result); result = NULL; } goto got_result; }
static void roqet_graph_pattern_walk(rasqal_graph_pattern *gp, int gp_index, FILE *fh, int indent) { int triple_index = 0; rasqal_graph_pattern_operator op; int seen; raptor_sequence *seq; int idx; rasqal_expression* expr; rasqal_variable* var; rasqal_literal* literal; op = rasqal_graph_pattern_get_operator(gp); roqet_write_indent(fh, indent); fprintf(fh, "%s graph pattern", rasqal_graph_pattern_operator_as_string(op)); idx = rasqal_graph_pattern_get_index(gp); if(idx >= 0) fprintf(fh, "[%d]", idx); if(gp_index >= 0) fprintf(fh, " #%d", gp_index); fputs(" {\n", fh); indent += 2; /* look for LET variable and value */ var = rasqal_graph_pattern_get_variable(gp); if(var) { roqet_write_indent(fh, indent); fprintf(fh, "%s := ", var->name); rasqal_expression_print(var->expression, fh); } /* look for GRAPH literal */ literal = rasqal_graph_pattern_get_origin(gp); if(literal) { roqet_write_indent(fh, indent); fputs("origin ", fh); rasqal_literal_print(literal, fh); fputc('\n', fh); } /* look for SERVICE literal */ literal = rasqal_graph_pattern_get_service(gp); if(literal) { roqet_write_indent(fh, indent); rasqal_literal_print(literal, fh); fputc('\n', fh); } /* look for triples */ seen = 0; while(1) { rasqal_triple* t; t = rasqal_graph_pattern_get_triple(gp, triple_index); if(!t) break; if(!seen) { roqet_write_indent(fh, indent); fputs("triples {\n", fh); seen = 1; } roqet_write_indent(fh, indent + 2); fprintf(fh, "triple #%d { ", triple_index); rasqal_triple_print(t, fh); fputs(" }\n", fh); triple_index++; } if(seen) { roqet_write_indent(fh, indent); fputs("}\n", fh); } /* look for sub-graph patterns */ seq = rasqal_graph_pattern_get_sub_graph_pattern_sequence(gp); if(seq && raptor_sequence_size(seq) > 0) { roqet_write_indent(fh, indent); fprintf(fh, "sub-graph patterns (%d) {\n", raptor_sequence_size(seq)); gp_index = 0; while(1) { rasqal_graph_pattern* sgp; sgp = rasqal_graph_pattern_get_sub_graph_pattern(gp, gp_index); if(!sgp) break; roqet_graph_pattern_walk(sgp, gp_index, fh, indent + 2); gp_index++; } roqet_write_indent(fh, indent); fputs("}\n", fh); } /* look for filter */ expr = rasqal_graph_pattern_get_filter_expression(gp); if(expr) { roqet_write_indent(fh, indent); fputs("filter { ", fh); rasqal_expression_print(expr, fh); fputs("}\n", fh); } indent -= 2; roqet_write_indent(fh, indent); fputs("}\n", fh); }
int main(int argc, char **argv) { const char *program=rasqal_basename(argv[0]); rasqal_query *query = NULL; rasqal_query_results *results = NULL; raptor_uri *base_uri; unsigned char *data_string; unsigned char *uri_string; const char *query_language_name=QUERY_LANGUAGE; const char *query_format=QUERY_FORMAT; unsigned char *query_string; int count; rasqal_world *world; const char *data_file; world=rasqal_new_world(); if(!world || rasqal_world_open(world)) { fprintf(stderr, "%s: rasqal_world init failed\n", program); return(1); } if((data_file = getenv("RDF_DATA_FILE"))) { /* got data from environment */ } else { if(argc != 2) { fprintf(stderr, "USAGE: %s data-filename\n", program); return(1); } data_file = argv[1]; } data_string = raptor_uri_filename_to_uri_string(data_file); query_string=(unsigned char*)RASQAL_MALLOC(cstring, strlen((const char*)data_string)+strlen(query_format)+1); sprintf((char*)query_string, query_format, data_string); raptor_free_memory(data_string); uri_string=raptor_uri_filename_to_uri_string(""); base_uri = raptor_new_uri(world->raptor_world_ptr, uri_string); raptor_free_memory(uri_string); query=rasqal_new_query(world, query_language_name, NULL); if(!query) { fprintf(stderr, "%s: creating query in language %s FAILED\n", program, query_language_name); return(1); } printf("%s: preparing %s query\n", program, query_language_name); if(rasqal_query_prepare(query, query_string, base_uri)) { fprintf(stderr, "%s: %s query prepare FAILED\n", program, query_language_name); return(1); } RASQAL_FREE(cstring, query_string); printf("%s: executing query #1\n", program); results=rasqal_query_execute(query); if(!results) { fprintf(stderr, "%s: query execution 1 FAILED\n", program); return(1); } count=0; while(results && !rasqal_query_results_finished(results)) { int i; for(i=0; i<rasqal_query_results_get_bindings_count(results); i++) { const unsigned char *name=rasqal_query_results_get_binding_name(results, i); rasqal_literal *value=rasqal_query_results_get_binding_value(results, i); printf("result %d: variable %s=", count+1, (char*)name); rasqal_literal_print(value, stdout); putchar('\n'); } rasqal_query_results_next(results); count++; } if(results) rasqal_free_query_results(results); if(count != EXPECTED_RESULTS_COUNT) { fprintf(stderr, "%s: query execution 1 returned %d results, expected %d\n", program, count, EXPECTED_RESULTS_COUNT); return(1); } printf("%s: executing query #2\n", program); results = rasqal_query_execute(query); if(!results) { fprintf(stderr, "%s: query execution 2 FAILED\n", program); return(1); } count=0; while(results && !rasqal_query_results_finished(results)) { int i; for(i=0; i<rasqal_query_results_get_bindings_count(results); i++) { const unsigned char *name=rasqal_query_results_get_binding_name(results, i); rasqal_literal *value=rasqal_query_results_get_binding_value(results, i); printf("result %d: variable %s=", count+1, (char*)name); rasqal_literal_print(value, stdout); putchar('\n'); } rasqal_query_results_next(results); count++; } if(results) rasqal_free_query_results(results); if(count != EXPECTED_RESULTS_COUNT) { fprintf(stderr, "%s: query execution 2 returned %d results, expected %d\n", program, count, EXPECTED_RESULTS_COUNT); return(1); } printf("%s: executing query #3\n", program); results = rasqal_query_execute(query); if(!results) { fprintf(stderr, "%s: query execution 3 FAILED\n", program); return(1); } rasqal_free_query_results(results); printf("%s: executing query #4\n", program); results = rasqal_query_execute(query); if(!results) { fprintf(stderr, "%s: query execution 4 FAILED\n", program); return(1); } rasqal_free_query_results(results); rasqal_free_query(query); raptor_free_uri(base_uri); rasqal_free_world(world); return 0; }