static rasqal_row*
rasqal_join_rowsource_build_merged_row(rasqal_rowsource* rowsource,
rasqal_join_rowsource_context* con,
rasqal_row *right_row)
{
rasqal_row *row;
int i;
row = rasqal_new_row_for_size(rowsource->world, rowsource->size);
if(!row) {
if(right_row)
rasqal_free_row(right_row);
return NULL;
}
rasqal_row_set_rowsource(row, rowsource);
row->offset = con->offset;
#ifdef RASQAL_DEBUG
RASQAL_DEBUG1("merge\n left row : ");
rasqal_row_print(con->left_row, stderr);
fputs("\n right row : ", stderr);
if(right_row)
rasqal_row_print(right_row, stderr);
else
fputs("NONE", stderr);
fputs("\n", stderr);
#endif
for(i = 0; i < con->left_row->size; i++) {
rasqal_literal *l = con->left_row->values[i];
row->values[i] = rasqal_new_literal_from_literal(l);
}
if(right_row) {
for(i = 0; i < right_row->size; i++) {
rasqal_literal *l = right_row->values[i];
int dest_i = con->right_map[i];
if(!row->values[dest_i])
row->values[dest_i] = rasqal_new_literal_from_literal(l);
}
rasqal_free_row(right_row);
}
#ifdef RASQAL_DEBUG
fputs(" result row : ", stderr);
if(row)
rasqal_row_print(row, stderr);
else
fputs("NONE", stderr);
fputs("\n", stderr);
#endif
return row;
}
static rasqal_row*
rasqal_graph_rowsource_read_row(rasqal_rowsource* rowsource, void *user_data)
{
rasqal_graph_rowsource_context *con;
rasqal_row* row = NULL;
con = (rasqal_graph_rowsource_context*)user_data;
if(con->finished)
return NULL;
while(1) {
row = rasqal_rowsource_read_row(con->rowsource);
if(row)
break;
if(rasqal_graph_next_dg(con)) {
con->finished = 1;
break;
}
if(rasqal_rowsource_reset(con->rowsource)) {
con->finished = 1;
break;
}
}
/* If a row is returned, put the GRAPH variable value as first literal */
if(row) {
rasqal_row* nrow;
int i;
nrow = rasqal_new_row_for_size(rowsource->world, 1 + row->size);
if(!nrow) {
rasqal_free_row(row);
row = NULL;
} else {
nrow->rowsource = rowsource;
nrow->offset = row->offset;
/* Put GRAPH variable value (or NULL) first in result row */
nrow->values[0] = rasqal_new_literal_from_literal(con->var->value);
/* Copy (size-1) remaining variables from input row */
for(i = 0; i < row->size; i++)
nrow->values[i + 1] = rasqal_new_literal_from_literal(row->values[i]);
rasqal_free_row(row);
row = nrow;
}
}
return row;
}
/**
* 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;
}
