/**
* rasqal_new_variable_typed:
* @rq: #rasqal_query to associate the variable with
* @type: variable type defined by enumeration rasqal_variable_type
* @name: variable name
* @value: variable #rasqal_literal value (or NULL)
*
* Constructor - Create a new typed Rasqal variable.
*
* The variable must be associated with a query, since variable
* names are only significant with a single query.
*
* The @name and @value become owned by the rasqal_variable structure
*
* @Deprecated: for rasqal_variables_table_add()
*
* Return value: a new #rasqal_variable or NULL on failure.
**/
rasqal_variable*
rasqal_new_variable_typed(rasqal_query* rq,
rasqal_variable_type type,
unsigned char *name, rasqal_literal *value)
{
return rasqal_variables_table_add(rq->vars_table, type, name, value);
}
/**
* rasqal_new_variable:
* @rq: #rasqal_query to associate the variable with
* @name: variable name
* @value: variable #rasqal_literal value (or NULL)
*
* Constructor - Create a new Rasqal normal variable.
*
* The variable must be associated with a query, since variable
* names are only significant with a single query.
*
* This creates a regular variable that can be returned of type
* RASQAL_VARIABLE_TYPE_NORMAL. Use rasqal_new_variable_typed
* to create other variables.
*
* The @name and @value become owned by the rasqal_variable structure
*
* @Deprecated: for rasqal_variables_table_add()
*
* Return value: a new #rasqal_variable or NULL on failure.
**/
rasqal_variable*
rasqal_new_variable(rasqal_query* rq,
unsigned char *name, rasqal_literal *value)
{
return rasqal_variables_table_add(rq->vars_table, RASQAL_VARIABLE_TYPE_NORMAL,
name, value);
}
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_world* world = NULL;
rasqal_variables_table* vt = NULL;
#define NUM_VARS 3
const char* var_names[NUM_VARS] = {"normal-null", "normal-value", "anon"};
unsigned char* names[NUM_VARS];
rasqal_variable* vars[NUM_VARS];
rasqal_literal *value = NULL;
int i;
int rc = 0;
world = rasqal_new_world();
if(!world || rasqal_world_open(world)) {
fprintf(stderr, "%s: rasqal_world init failed\n", program);
rc = 1;
goto tidy;
}
vt = rasqal_new_variables_table(world);
if(!vt) {
fprintf(stderr, "%s: Failed to make variables table\n", program);
rc = 1;
goto tidy;
}
for(i = 0; i < NUM_VARS; i++) {
size_t len = strlen(var_names[i]);
names[i] = (unsigned char*)malloc(len+1);
memcpy(names[i], var_names[i], len + 1);
}
vars[0] = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_NORMAL,
names[0], NULL);
if(!vars[0]) {
fprintf(stderr, "%s: Failed to make normal variable with NULL value\n",
program);
rc = 1;
goto tidy;
} else {
/* now owned by vars[0] owned by vt */
names[0] = NULL;
}
/* vars[0] now owned by vt */
value = rasqal_new_double_literal(world, 42.0);
if(!value) {
fprintf(stderr, "%s: Failed to make double literal\n", program);
rc = 1;
goto tidy;
}
vars[1] = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_NORMAL,
names[1], value);
if(!vars[1]) {
fprintf(stderr, "%s: Failed to make normal variable with literal value\n",
program);
rc = 1;
goto tidy;
} else {
/* now owned by vars[1] owned by vt */
names[1] = NULL;
value = NULL;
}
/* vars[1] now owned by vt */
vars[2] = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_ANONYMOUS,
names[2], NULL);
if(!vars[2]) {
fprintf(stderr, "%s: Failed to make anonymous variable with NULL value\n",
program);
rc = 1;
goto tidy;
} else {
/* now owned by vars[2] owned by vt */
names[2] = NULL;
}
/* vars[2] now owned by vt */
tidy:
for(i = 0; i < NUM_VARS; i++) {
if(names[i])
free(names[i]);
}
if(value)
rasqal_free_literal(value);
if(vt)
rasqal_free_variables_table(vt);
if(world)
rasqal_free_world(world);
return 0;
}
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++;
}
/**
* rasqal_new_row_sequence:
* @world: world object ot use
* @vt: variables table to use to declare variables
* @row_data: row data
* @vars_count: number of variables in row
* @vars_seq_p: OUT parameter - pointer to place to store sequence of variables (or NULL)
*
* INTERNAL - Make a sequence of #rasqal_row* objects
* with variables defined into the @vt table and values in the sequence
*
* The @row_data parameter is an array of strings forming a table of
* width (vars_count * 2).
* The first row is a list of variable names at offset 0.
* The remaining rows are values where offset 0 is a literal and
* offset 1 is a URI string.
*
* The last row is indicated by an entire row of NULLs.
*
* Return value: sequence of rows or NULL on failure
*/
raptor_sequence*
rasqal_new_row_sequence(rasqal_world* world,
rasqal_variables_table* vt,
const char* const row_data[],
int vars_count,
raptor_sequence** vars_seq_p)
{
raptor_sequence *seq = NULL;
raptor_sequence *vars_seq = NULL;
int row_i;
int column_i;
int failed = 0;
#define GET_CELL(row, column, offset) \
row_data[((((row)*vars_count)+(column))<<1)+(offset)]
seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_row,
(raptor_data_print_handler)rasqal_row_print);
if(!seq)
return NULL;
if(vars_seq_p) {
vars_seq = raptor_new_sequence((raptor_data_free_handler)rasqal_free_variable,
(raptor_data_print_handler)rasqal_variable_print);
if(!vars_seq) {
raptor_free_sequence(seq);
return NULL;
}
}
/* row 0 is variables */
row_i = 0;
for(column_i = 0; column_i < vars_count; column_i++) {
const char * var_name = GET_CELL(row_i, column_i, 0);
size_t var_name_len = strlen(var_name);
const unsigned char* name;
rasqal_variable* v;
name = (unsigned char*)RASQAL_MALLOC(cstring, var_name_len+1);
if(!name) {
failed = 1;
goto tidy;
}
memcpy((void*)name, var_name, var_name_len + 1);
v = rasqal_variables_table_add(vt, RASQAL_VARIABLE_TYPE_NORMAL, name, NULL);
if(!v) {
failed = 1;
goto tidy;
}
if(vars_seq) {
v = rasqal_new_variable_from_variable(v);
raptor_sequence_push(vars_seq, v);
}
}
for(row_i = 1; 1; row_i++) {
rasqal_row* row;
int data_values_seen = 0;
/* Terminate on an entire row of NULLs */
for(column_i = 0; column_i < vars_count; column_i++) {
if(GET_CELL(row_i, column_i, 0) || GET_CELL(row_i, column_i, 1)) {
data_values_seen++;
break;
}
}
if(!data_values_seen)
break;
row = rasqal_new_row_for_size(world, vars_count);
if(!row) {
raptor_free_sequence(seq); seq = NULL;
goto tidy;
}
for(column_i = 0; column_i < vars_count; column_i++) {
rasqal_literal* l = NULL;
if(GET_CELL(row_i, column_i, 0)) {
/* string literal */
const char* str = GET_CELL(row_i, column_i, 0);
size_t str_len = strlen(str);
char *eptr = NULL;
int integer;
integer = (int)strtol((const char*)str, &eptr, 10);
if(!*eptr) {
/* is an integer */
l = rasqal_new_integer_literal(world, RASQAL_LITERAL_INTEGER,
integer);
} else {
unsigned char *val;
val = (unsigned char*)RASQAL_MALLOC(cstring, str_len+1);
if(val) {
memcpy(val, str, str_len + 1);
l = rasqal_new_string_literal_node(world, val, NULL, NULL);
} else
failed = 1;
}
} else if(GET_CELL(row_i, column_i, 1)) {
/* URI */
const unsigned char* str;
raptor_uri* u;
str = (const unsigned char*)GET_CELL(row_i, column_i, 1);
u = raptor_new_uri(world->raptor_world_ptr, str);
if(u)
l = rasqal_new_uri_literal(world, u);
else
failed = 1;
} else {
/* variable is not defined for this row */
continue;
}
if(!l) {
rasqal_free_row(row);
failed = 1;
goto tidy;
}
rasqal_row_set_value_at(row, column_i, l);
/* free our copy of literal, rasqal_row has a reference */
rasqal_free_literal(l);
}
raptor_sequence_push(seq, row);
}
tidy:
if(failed) {
if(seq) {
raptor_free_sequence(seq);
seq = NULL;
}
if(vars_seq) {
raptor_free_sequence(vars_seq);
vars_seq = NULL;
}
} else {
if(vars_seq) {
if(vars_seq_p)
*vars_seq_p = vars_seq;
else
raptor_free_sequence(vars_seq);
}
}
return seq;
}
