/* * rasqal_query_results_write_json1: * @iostr: #raptor_iostream to write the query to * @results: #rasqal_query_results query results format * @base_uri: #raptor_uri base URI of the output format * * Write a JSON version of the query results format to an * iostream in a format - INTERNAL. * * If the writing succeeds, the query results will be exhausted. * * Return value: non-0 on failure **/ static int rasqal_query_results_write_json1(rasqal_query_results_formatter* formatter, raptor_iostream *iostr, rasqal_query_results* results, raptor_uri *base_uri) { rasqal_world* world = rasqal_query_results_get_world(results); rasqal_query* query = rasqal_query_results_get_query(results); int i; int row_comma; int column_comma = 0; rasqal_query_results_type type; type = rasqal_query_results_get_type(results); if(type != RASQAL_QUERY_RESULTS_BINDINGS && type != RASQAL_QUERY_RESULTS_BOOLEAN) { rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "Cannot write JSON for %s query result format", rasqal_query_results_type_label(type)); return 1; } raptor_iostream_counted_string_write("{\n", 2, iostr); /* Header */ raptor_iostream_counted_string_write(" \"head\": {\n", 12, iostr); if(rasqal_query_results_is_bindings(results)) { raptor_iostream_counted_string_write(" \"vars\": [ ", 14, iostr); for(i = 0; 1; i++) { const unsigned char *name; name = rasqal_query_results_get_binding_name(results, i); if(!name) break; /* 'x', */ if(i > 0) raptor_iostream_counted_string_write(", ", 2, iostr); raptor_iostream_write_byte('\"', iostr); raptor_iostream_string_write(name, iostr); raptor_iostream_write_byte('\"', iostr); } raptor_iostream_counted_string_write(" ]\n", 3, iostr); } /* FIXME - could add link inside 'head': */ /* End Header */ raptor_iostream_counted_string_write(" },\n", 5, iostr); /* Boolean Results */ if(rasqal_query_results_is_boolean(results)) { raptor_iostream_counted_string_write(" ", 2, iostr); rasqal_iostream_write_json_boolean(iostr, "boolean", rasqal_query_results_get_boolean(results)); goto results3done; } /* Variable Binding Results */ raptor_iostream_counted_string_write(" \"results\": {\n", 15, iostr); if(query) { raptor_iostream_counted_string_write(" ", 4, iostr); rasqal_iostream_write_json_boolean(iostr, "ordered", (rasqal_query_get_order_condition(query, 0) != NULL)); raptor_iostream_counted_string_write(",\n", 2, iostr); raptor_iostream_counted_string_write(" ", 4, iostr); rasqal_iostream_write_json_boolean(iostr, "distinct", rasqal_query_get_distinct(query)); raptor_iostream_counted_string_write(",\n", 2, iostr); } raptor_iostream_counted_string_write(" \"bindings\" : [\n", 19, iostr); row_comma = 0; while(!rasqal_query_results_finished(results)) { if(row_comma) raptor_iostream_counted_string_write(",\n", 2, iostr); /* Result row */ raptor_iostream_counted_string_write(" {\n", 8, iostr); column_comma = 0; 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 *l = rasqal_query_results_get_binding_value(results, i); if(column_comma) raptor_iostream_counted_string_write(",\n", 2, iostr); /* <binding> */ raptor_iostream_counted_string_write(" \"", 9, iostr); raptor_iostream_string_write(name, iostr); raptor_iostream_counted_string_write("\" : { ", 6, iostr); if(!l) { raptor_iostream_string_write("\"type\": \"unbound\", \"value\": null", iostr); } else { const unsigned char* str; size_t len; switch(l->type) { case RASQAL_LITERAL_URI: raptor_iostream_string_write("\"type\": \"uri\", \"value\": \"", iostr); str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->value.uri, &len)); raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte('"', iostr); break; case RASQAL_LITERAL_BLANK: raptor_iostream_string_write("\"type\": \"bnode\", \"value\": \"", iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_write_byte('"', iostr); break; case RASQAL_LITERAL_STRING: raptor_iostream_string_write("\"type\": \"literal\", \"value\": \"", iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_write_byte('"', iostr); if(l->language) { raptor_iostream_string_write(",\n \"xml:lang\" : \"", iostr); raptor_iostream_string_write(RASQAL_GOOD_CAST(const unsigned char*, l->language), iostr); raptor_iostream_write_byte('"', iostr); } if(l->datatype) { raptor_iostream_string_write(",\n \"datatype\" : \"", iostr); str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->datatype, &len)); raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte('"', iostr); } break; case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_VARIABLE: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATE: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: case RASQAL_LITERAL_UNKNOWN: default: rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Cannot turn literal type %u into XML", l->type); } } /* End Binding */ raptor_iostream_counted_string_write(" }", 2, iostr); column_comma = 1; }
/* * rasqal_query_results_write_sv: * @iostr: #raptor_iostream to write the query to * @results: #rasqal_query_results query results format * @base_uri: #raptor_uri base URI of the output format * @label: name of this format for errors * @sep: column sep character * * INTERNAL - Write a @sep-separated values version of the query results format to an iostream. * * If the writing succeeds, the query results will be exhausted. * * Return value: non-0 on failure **/ static int rasqal_query_results_write_sv(raptor_iostream *iostr, rasqal_query_results* results, raptor_uri *base_uri, const char* label, char sep) { rasqal_query* query = rasqal_query_results_get_query(results); int i; int count = 1; #define empty_value_str_len 0 static const char empty_value_str[empty_value_str_len+1] = ""; #define nl_str_len 1 static const char nl_str[nl_str_len+1] = "\n"; int vars_count; if(!rasqal_query_results_is_bindings(results)) { rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "Can only write %s format for variable binding results", label); return 1; } /* Header */ raptor_iostream_counted_string_write("Result", 6, iostr); for(i = 0; 1; i++) { const unsigned char *name; name = rasqal_query_results_get_binding_name(results, i); if(!name) break; raptor_iostream_write_byte(sep, iostr); raptor_iostream_string_write(name, iostr); } raptor_iostream_counted_string_write(nl_str, nl_str_len, iostr); /* Variable Binding Results */ vars_count = rasqal_query_results_get_bindings_count(results); while(!rasqal_query_results_finished(results)) { /* Result row */ raptor_iostream_decimal_write(count++, iostr); for(i = 0; i < vars_count; i++) { rasqal_literal *l = rasqal_query_results_get_binding_value(results, i); raptor_iostream_write_byte(sep, iostr); if(!l) { if(empty_value_str_len) raptor_iostream_counted_string_write(empty_value_str, empty_value_str_len, iostr); } else switch(l->type) { const unsigned char* str; size_t len; case RASQAL_LITERAL_URI: raptor_iostream_string_write("uri(", iostr); str = (const unsigned char*)raptor_uri_as_counted_string(l->value.uri, &len); raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte(')', iostr); break; case RASQAL_LITERAL_BLANK: raptor_iostream_string_write("blank(", iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_write_byte(')', iostr); break; case RASQAL_LITERAL_STRING: if(l->datatype && l->valid) { rasqal_literal_type ltype; ltype = rasqal_xsd_datatype_uri_to_type(l->world, l->datatype); if(ltype >= RASQAL_LITERAL_INTEGER && ltype <= RASQAL_LITERAL_DECIMAL) { /* write integer, float, double and decimal XSD typed * data without quotes, datatype or language */ raptor_string_ntriples_write(l->string, l->string_len, '\0', iostr); break; } } raptor_iostream_write_byte('"', iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_write_byte('"', iostr); if(l->language) { raptor_iostream_write_byte('@', iostr); raptor_iostream_string_write((const unsigned char*)l->language, iostr); } if(l->datatype) { raptor_iostream_string_write("^^uri(", iostr); str = (const unsigned char*)raptor_uri_as_counted_string(l->datatype, &len); raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte(')', iostr); } break; case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_VARIABLE: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: case RASQAL_LITERAL_UNKNOWN: default: rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "Cannot turn literal type %d into %s", l->type, label); } /* End Binding */ } /* End Result Row */ raptor_iostream_counted_string_write(nl_str, nl_str_len, iostr); rasqal_query_results_next(results); } /* end sparql */ return 0; }
/* * Return value: non-0 if equal */ static int compare_query_results_compare(compare_query_results* cqr) { int differences = 0; int i; int rowi; int size1; int size2; int row_differences_count = 0; size1 = rasqal_query_results_get_bindings_count(cqr->qr1); size2 = rasqal_query_results_get_bindings_count(cqr->qr2); if(size1 != size2) { cqr->message.level = RAPTOR_LOG_LEVEL_ERROR; cqr->message.text = "Results have different numbers of bindings"; if(cqr->log_handler) cqr->log_handler(cqr->log_user_data, &cqr->message); differences++; goto done; } /* check variables in each results project the same variables */ for(i = 0; 1; i++) { const unsigned char* v1; const unsigned char* v2; v1 = rasqal_query_results_get_binding_name(cqr->qr1, i); v2 = rasqal_query_results_get_binding_name(cqr->qr2, i); if(!v1 && !v2) break; if(v1 && v2) { if(strcmp((const char*)v1, (const char*)v2)) { /* different names */ differences++; } } else /* one is NULL, the other is a name */ differences++; } if(differences) { cqr->message.level = RAPTOR_LOG_LEVEL_ERROR; cqr->message.text = "Results have different binding names"; if(cqr->log_handler) cqr->log_handler(cqr->log_user_data, &cqr->message); goto done; } /* set results to be stored? */ /* sort rows by something ? As long as the sort is the same it * probably does not matter what the method is. */ /* what to do about blank nodes? */ /* for each row */ for(rowi = 0; 1; rowi++) { int bindingi; rasqal_row* row1 = rasqal_query_results_get_row_by_offset(cqr->qr1, rowi); rasqal_row* row2 = rasqal_query_results_get_row_by_offset(cqr->qr2, rowi); int this_row_different = 0; if(!row1 && !row2) break; /* for each variable in row1 (== same variables in row2) */ for(bindingi = 0; bindingi < size1; bindingi++) { /* we know the binding names are the same */ const unsigned char* name; rasqal_literal *value1; rasqal_literal *value2; int error = 0; name = rasqal_query_results_get_binding_name(cqr->qr1, bindingi); value1 = rasqal_query_results_get_binding_value(cqr->qr1, bindingi); value2 = rasqal_query_results_get_binding_value(cqr->qr2, bindingi); /* should have compare as native flag? * RASQAL_COMPARE_XQUERY doesn't compare all values */ if(!rasqal_literal_equals_flags(value1, value2, RASQAL_COMPARE_XQUERY, &error)) { /* if different report it */ raptor_world* raptor_world_ptr; void *string; size_t length; raptor_iostream* string_iostr; raptor_world_ptr = rasqal_world_get_raptor(cqr->world); string_iostr = raptor_new_iostream_to_string(raptor_world_ptr, &string, &length, (raptor_data_malloc_handler)malloc); raptor_iostream_counted_string_write("Difference in row ", 18, string_iostr); raptor_iostream_decimal_write(rowi + 1, string_iostr); raptor_iostream_counted_string_write(" binding '", 10, string_iostr); raptor_iostream_string_write(name, string_iostr); raptor_iostream_counted_string_write("' ", 2, string_iostr); raptor_iostream_string_write(cqr->qr1_label, string_iostr); raptor_iostream_counted_string_write(" value ", 7, string_iostr); rasqal_literal_write(value1, string_iostr); raptor_iostream_write_byte(' ', string_iostr); raptor_iostream_string_write(cqr->qr2_label, string_iostr); raptor_iostream_counted_string_write(" value ", 7, string_iostr); rasqal_literal_write(value2, string_iostr); raptor_iostream_write_byte(' ', string_iostr); /* this allocates and copies result into 'string' */ raptor_free_iostream(string_iostr); cqr->message.level = RAPTOR_LOG_LEVEL_ERROR; cqr->message.text = (const char*)string; if(cqr->log_handler) cqr->log_handler(cqr->log_user_data, &cqr->message); free(string); differences++; this_row_different = 1; } } /* end for each var */ if(this_row_different) row_differences_count++; rasqal_query_results_next(cqr->qr1); rasqal_query_results_next(cqr->qr2); } /* end for each row */ if(row_differences_count) { cqr->message.level = RAPTOR_LOG_LEVEL_ERROR; cqr->message.text = "Results have different values"; if(cqr->log_handler) cqr->log_handler(cqr->log_user_data, &cqr->message); } done: return (differences == 0); }
/* * rasqal_query_results_write_sv: * @iostr: #raptor_iostream to write the query to * @results: #rasqal_query_results query results format * @base_uri: #raptor_uri base URI of the output format * @label: name of this format for errors * @sep: column sep character * @csv_escape: non-0 if values are written escaped with CSV rules, else turtle * @variable_prefix: char to print before a variable name or NUL * @eol_str: end of line string * @eol_str_len: length of @eol_str * * INTERNAL - Write a @sep-separated values version of the query results format to an iostream. * * If the writing succeeds, the query results will be exhausted. * * Return value: non-0 on failure **/ static int rasqal_query_results_write_sv(raptor_iostream *iostr, rasqal_query_results* results, raptor_uri *base_uri, const char* label, const char sep, int csv_escape, const char variable_prefix, const char* eol_str, size_t eol_str_len) { rasqal_query* query = rasqal_query_results_get_query(results); int i; int vars_count; if(!rasqal_query_results_is_bindings(results)) { rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "Can only write %s format for variable binding results", label); return 1; } /* Header */ for(i = 0; 1; i++) { const unsigned char *name; name = rasqal_query_results_get_binding_name(results, i); if(!name) break; if(i > 0) raptor_iostream_write_byte(sep, iostr); if(variable_prefix) raptor_iostream_write_byte(variable_prefix, iostr); raptor_iostream_string_write(name, iostr); } raptor_iostream_counted_string_write(eol_str, eol_str_len, iostr); /* Variable Binding Results */ vars_count = rasqal_query_results_get_bindings_count(results); while(!rasqal_query_results_finished(results)) { /* Result row */ for(i = 0; i < vars_count; i++) { rasqal_literal *l = rasqal_query_results_get_binding_value(results, i); if(i > 0) raptor_iostream_write_byte(sep, iostr); if(l) { const unsigned char* str; size_t len; switch(l->type) { case RASQAL_LITERAL_URI: str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->value.uri, &len)); if(csv_escape) rasqal_iostream_write_csv_string(str, len, iostr); else { raptor_iostream_write_byte('<', iostr); if(str && len > 0) raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte('>', iostr); } break; case RASQAL_LITERAL_BLANK: raptor_bnodeid_ntriples_write(l->string, l->string_len, iostr); break; case RASQAL_LITERAL_STRING: if(csv_escape) { rasqal_iostream_write_csv_string(l->string, l->string_len, iostr); } else { if(l->datatype && l->valid) { rasqal_literal_type ltype; ltype = rasqal_xsd_datatype_uri_to_type(l->world, l->datatype); if(ltype >= RASQAL_LITERAL_INTEGER && ltype <= RASQAL_LITERAL_DECIMAL) { /* write integer, float, double and decimal XSD typed * data without quotes, datatype or language */ raptor_string_ntriples_write(l->string, l->string_len, '\0', iostr); break; } } raptor_iostream_write_byte('"', iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_write_byte('"', iostr); if(l->language) { raptor_iostream_write_byte('@', iostr); raptor_iostream_string_write(RASQAL_GOOD_CAST(const unsigned char*, l->language), iostr); } if(l->datatype) { raptor_iostream_string_write("^^<", iostr); str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->datatype, &len)); raptor_string_ntriples_write(str, len, '"', iostr); raptor_iostream_write_byte('>', iostr); } } break; case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_VARIABLE: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATE: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: case RASQAL_LITERAL_UNKNOWN: default: rasqal_log_error_simple(query->world, RAPTOR_LOG_LEVEL_ERROR, &query->locator, "Cannot turn literal type %d into %s", l->type, label); } } /* End Binding */ }
/** * raptor_string_escaped_write: * @string: UTF-8 string to write * @len: length of UTF-8 string * @delim: Terminating delimiter character for string (such as " or >) or \0 for no escaping. * @flags: bit flags - see #raptor_escaped_write_bitflags * @iostr: #raptor_iostream to write to * * Write a UTF-8 string formatted using different escapes to a #raptor_iostream * * Supports writing escapes in the Python, N-Triples, Turtle, JSON, mKR, * SPARQL styles to an iostream. * * Return value: non-0 on failure such as bad UTF-8 encoding. **/ int raptor_string_escaped_write(const unsigned char *string, size_t len, const char delim, unsigned int flags, raptor_iostream *iostr) { unsigned char c; int unichar_len; raptor_unichar unichar; if(!string) return 1; for(; (c=*string); string++, len--) { if((delim && c == delim && (delim == '\'' || delim == '"')) || c == '\\') { raptor_iostream_write_byte('\\', iostr); raptor_iostream_write_byte(c, iostr); continue; } if(delim && c == delim) { raptor_iostream_counted_string_write("\\u", 2, iostr); raptor_iostream_hexadecimal_write(c, 4, iostr); continue; } if(flags & RAPTOR_ESCAPED_WRITE_BITFLAG_SPARQL_URI_ESCAPES) { /* Must escape #x00-#x20<>\"{}|^` */ if(c <= 0x20 || c == '<' || c == '>' || c == '\\' || c == '"' || c == '{' || c == '}' || c == '|' || c == '^' || c == '`') { raptor_iostream_counted_string_write("\\u", 2, iostr); raptor_iostream_hexadecimal_write(c, 4, iostr); continue; } else if(c < 0x7f) { raptor_iostream_write_byte(c, iostr); continue; } } if(flags & RAPTOR_ESCAPED_WRITE_BITFLAG_BS_ESCAPES_TNRU) { if(c == 0x09) { raptor_iostream_counted_string_write("\\t", 2, iostr); continue; } else if(c == 0x0a) { raptor_iostream_counted_string_write("\\n", 2, iostr); continue; } else if(c == 0x0d) { raptor_iostream_counted_string_write("\\r", 2, iostr); continue; } else if(c < 0x20 || c == 0x7f) { raptor_iostream_counted_string_write("\\u", 2, iostr); raptor_iostream_hexadecimal_write(c, 4, iostr); continue; } } if(flags & RAPTOR_ESCAPED_WRITE_BITFLAG_BS_ESCAPES_BF) { if(c == 0x08) { /* JSON has \b for backspace */ raptor_iostream_counted_string_write("\\b", 2, iostr); continue; } else if(c == 0x0b) { /* JSON has \f for formfeed */ raptor_iostream_counted_string_write("\\f", 2, iostr); continue; } } /* Just format remaining characters */ if(c < 0x7f) { raptor_iostream_write_byte(c, iostr); continue; } /* It is unicode */ unichar_len = raptor_unicode_utf8_string_get_char(string, len, &unichar); if(unichar_len < 0 || RAPTOR_GOOD_CAST(size_t, unichar_len) > len) /* UTF-8 encoding had an error or ended in the middle of a string */ return 1; if(flags & RAPTOR_ESCAPED_WRITE_BITFLAG_UTF8) { /* UTF-8 is allowed so no need to escape */ raptor_iostream_counted_string_write(string, unichar_len, iostr); } else { if(unichar < 0x10000) { raptor_iostream_counted_string_write("\\u", 2, iostr); raptor_iostream_hexadecimal_write(RAPTOR_GOOD_CAST(unsigned int, unichar), 4, iostr); } else { raptor_iostream_counted_string_write("\\U", 2, iostr); raptor_iostream_hexadecimal_write(RAPTOR_GOOD_CAST(unsigned int, unichar), 8, iostr); } }
/* return 0 to abort visit */ static int raptor_json_serialize_avltree_visit(int depth, void* data, void *user_data) { raptor_serializer* serializer = (raptor_serializer*)user_data; raptor_json_context* context = (raptor_json_context*)serializer->context; raptor_statement* statement = (raptor_statement*)data; raptor_statement* s1 = statement; raptor_statement* s2 = context->last_statement; int new_subject = 0; int new_predicate = 0; if(s2) { new_subject = !raptor_term_equals(s1->subject, s2->subject); if(new_subject) { /* end last predicate */ raptor_json_writer_newline(context->json_writer); raptor_json_writer_end_block(context->json_writer, ']'); raptor_json_writer_newline(context->json_writer); /* end last statement */ raptor_json_writer_end_block(context->json_writer, '}'); raptor_json_writer_newline(context->json_writer); context->need_subject_comma = 1; context->need_object_comma = 0; } } else new_subject = 1; if(new_subject) { if(context->need_subject_comma) { raptor_iostream_write_byte(',', serializer->iostream); raptor_json_writer_newline(context->json_writer); } /* start triple */ /* subject */ switch(s1->subject->type) { case RAPTOR_TERM_TYPE_URI: raptor_json_writer_key_uri_value(context->json_writer, NULL, 0, s1->subject->value.uri); break; case RAPTOR_TERM_TYPE_BLANK: raptor_iostream_counted_string_write("\"_:", 3, serializer->iostream); raptor_string_python_write(s1->subject->value.blank.string, 0, '"', 2, serializer->iostream); raptor_iostream_write_byte('"', serializer->iostream); break; case RAPTOR_TERM_TYPE_LITERAL: case RAPTOR_TERM_TYPE_UNKNOWN: default: raptor_log_error_formatted(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Triple has unsupported subject term type %d", s1->subject->type); break; } raptor_iostream_counted_string_write(" : ", 3, serializer->iostream); raptor_json_writer_start_block(context->json_writer, '{'); raptor_json_writer_newline(context->json_writer); } /* predicate */ if(context->last_statement) { if(new_subject) new_predicate = 1; else { new_predicate = !raptor_uri_equals(s1->predicate->value.uri, s2->predicate->value.uri); if(new_predicate) { raptor_json_writer_newline(context->json_writer); raptor_json_writer_end_block(context->json_writer, ']'); raptor_iostream_write_byte(',', serializer->iostream); raptor_json_writer_newline(context->json_writer); } } } else new_predicate = 1; if(new_predicate) { /* start predicate */ raptor_json_writer_key_uri_value(context->json_writer, NULL, 0, s1->predicate->value.uri); raptor_iostream_counted_string_write(" : ", 3, serializer->iostream); raptor_json_writer_start_block(context->json_writer, '['); raptor_iostream_write_byte(' ', serializer->iostream); context->need_object_comma = 0; } if(context->need_object_comma) { raptor_iostream_write_byte(',', serializer->iostream); raptor_json_writer_newline(context->json_writer); } /* object */ switch(s1->object->type) { case RAPTOR_TERM_TYPE_URI: raptor_json_writer_uri_object(context->json_writer, s1->object->value.uri); raptor_json_writer_newline(context->json_writer); break; case RAPTOR_TERM_TYPE_LITERAL: raptor_json_writer_literal_object(context->json_writer, s1->object->value.literal.string, s1->object->value.literal.language, s1->object->value.literal.datatype, "value", "type"); break; case RAPTOR_TERM_TYPE_BLANK: raptor_json_writer_blank_object(context->json_writer, s1->object->value.blank.string); raptor_json_writer_newline(context->json_writer); break; case RAPTOR_TERM_TYPE_UNKNOWN: default: raptor_log_error_formatted(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Triple has unsupported object term type %d", s1->object->type); break; } /* end triple */ context->need_object_comma = 1; context->last_statement = statement; return 1; }
static int raptor_xml_writer_start_element_common(raptor_xml_writer* xml_writer, raptor_xml_element* element, int auto_empty) { raptor_iostream* iostr = xml_writer->iostr; raptor_namespace_stack *nstack = xml_writer->nstack; int depth = xml_writer->depth; int auto_indent = XML_WRITER_AUTO_INDENT(xml_writer); int xml_version = XML_WRITER_XML_VERSION(xml_writer); struct nsd *nspace_declarations = NULL; size_t nspace_declarations_count = 0; unsigned int i; /* max is 1 per element and 1 for each attribute + size of declared */ if(nstack) { int nspace_max_count = element->attribute_count+1; if(element->declared_nspaces) nspace_max_count += raptor_sequence_size(element->declared_nspaces); nspace_declarations = (struct nsd*)RAPTOR_CALLOC(nsdarray, nspace_max_count, sizeof(struct nsd)); if(!nspace_declarations) return 1; } if(element->name->nspace) { if(nstack && !raptor_namespaces_namespace_in_scope(nstack, element->name->nspace)) { nspace_declarations[0].declaration= raptor_namespace_format_as_xml(element->name->nspace, &nspace_declarations[0].length); if(!nspace_declarations[0].declaration) goto error; nspace_declarations[0].nspace = element->name->nspace; nspace_declarations_count++; } } if(element->attributes) { for(i = 0; i < element->attribute_count; i++) { /* qname */ if(element->attributes[i]->nspace) { if(nstack && !raptor_namespaces_namespace_in_scope(nstack, element->attributes[i]->nspace) && element->attributes[i]->nspace != element->name->nspace) { /* not in scope and not same as element (so already going to be declared)*/ unsigned int j; int declare_me = 1; /* check it wasn't an earlier declaration too */ for(j = 0; j < nspace_declarations_count; j++) if(nspace_declarations[j].nspace == element->attributes[j]->nspace) { declare_me = 0; break; } if(declare_me) { nspace_declarations[nspace_declarations_count].declaration= raptor_namespace_format_as_xml(element->attributes[i]->nspace, &nspace_declarations[nspace_declarations_count].length); if(!nspace_declarations[nspace_declarations_count].declaration) goto error; nspace_declarations[nspace_declarations_count].nspace = element->attributes[i]->nspace; nspace_declarations_count++; } } } } } if(nstack && element->declared_nspaces && raptor_sequence_size(element->declared_nspaces) > 0) { for(i = 0; i< (unsigned int)raptor_sequence_size(element->declared_nspaces); i++) { raptor_namespace* nspace = (raptor_namespace*)raptor_sequence_get_at(element->declared_nspaces, i); unsigned int j; int declare_me = 1; /* check it wasn't an earlier declaration too */ for(j = 0; j < nspace_declarations_count; j++) if(nspace_declarations[j].nspace == nspace) { declare_me = 0; break; } if(declare_me) { nspace_declarations[nspace_declarations_count].declaration= raptor_namespace_format_as_xml(nspace, &nspace_declarations[nspace_declarations_count].length); if(!nspace_declarations[nspace_declarations_count].declaration) goto error; nspace_declarations[nspace_declarations_count].nspace = nspace; nspace_declarations_count++; } } } raptor_iostream_write_byte('<', iostr); if(element->name->nspace && element->name->nspace->prefix_length > 0) { raptor_iostream_counted_string_write((const char*)element->name->nspace->prefix, element->name->nspace->prefix_length, iostr); raptor_iostream_write_byte(':', iostr); } raptor_iostream_counted_string_write((const char*)element->name->local_name, element->name->local_name_length, iostr); /* declare namespaces */ if(nspace_declarations_count) { /* sort them into the canonical order */ qsort((void*)nspace_declarations, nspace_declarations_count, sizeof(struct nsd), raptor_xml_writer_nsd_compare); /* add them */ for(i = 0; i < nspace_declarations_count; i++) { if(auto_indent && nspace_declarations_count > 1) { /* indent xmlns namespace attributes */ raptor_xml_writer_newline(xml_writer); xml_writer->depth++; raptor_xml_writer_indent(xml_writer); xml_writer->depth--; } raptor_iostream_write_byte(' ', iostr); raptor_iostream_counted_string_write((const char*)nspace_declarations[i].declaration, nspace_declarations[i].length, iostr); RAPTOR_FREE(cstring, nspace_declarations[i].declaration); nspace_declarations[i].declaration = NULL; if(raptor_namespace_stack_start_namespace(nstack, (raptor_namespace*)nspace_declarations[i].nspace, depth)) goto error; } } if(element->attributes) { for(i = 0; i < element->attribute_count; i++) { raptor_iostream_write_byte(' ', iostr); if(element->attributes[i]->nspace && element->attributes[i]->nspace->prefix_length > 0) { raptor_iostream_counted_string_write((char*)element->attributes[i]->nspace->prefix, element->attributes[i]->nspace->prefix_length, iostr); raptor_iostream_write_byte(':', iostr); } raptor_iostream_counted_string_write((const char*)element->attributes[i]->local_name, element->attributes[i]->local_name_length, iostr); raptor_iostream_counted_string_write("=\"", 2, iostr); raptor_xml_escape_string_any_write(element->attributes[i]->value, element->attributes[i]->value_length, '"', xml_version, iostr); raptor_iostream_write_byte('"', iostr); } } if(!auto_empty) raptor_iostream_write_byte('>', iostr); if(nstack) RAPTOR_FREE(stringarray, nspace_declarations); return 0; /* Clean up nspace_declarations on error */ error: for(i = 0; i < nspace_declarations_count; i++) { if(nspace_declarations[i].declaration) RAPTOR_FREE(cstring, nspace_declarations[i].declaration); } if(nspace_declarations) RAPTOR_FREE(stringarray, nspace_declarations); return 1; }
static void rasqal_query_write_sparql_graph_pattern(sparql_writer_context *wc, raptor_iostream* iostr, rasqal_graph_pattern *gp, int gp_index, int indent) { int triple_index = 0; rasqal_graph_pattern_operator op; raptor_sequence *seq; int filters_count = 0; int want_braces = 1; op = rasqal_graph_pattern_get_operator(gp); if(op == RASQAL_GRAPH_PATTERN_OPERATOR_SELECT) { raptor_sequence* vars_seq; rasqal_graph_pattern* where_gp; raptor_iostream_counted_string_write("SELECT", 6, iostr); vars_seq = rasqal_projection_get_variables_sequence(gp->projection); rasqal_query_write_sparql_select(wc, iostr, vars_seq); raptor_iostream_write_byte('\n', iostr); rasqal_query_write_indent(iostr, indent); raptor_iostream_counted_string_write("WHERE ", 6, iostr); where_gp = rasqal_graph_pattern_get_sub_graph_pattern(gp, 0); rasqal_query_write_sparql_graph_pattern(wc, iostr, where_gp, 0, indent); /* FIXME - not implemented: modifiers */ return; } if(op == RASQAL_GRAPH_PATTERN_OPERATOR_LET) { /* LAQRS */ raptor_iostream_counted_string_write("LET (", 5, iostr); rasqal_query_write_sparql_variable(wc, iostr, gp->var); raptor_iostream_counted_string_write(" := ", 4, iostr); rasqal_query_write_sparql_expression(wc, iostr, gp->filter_expression); raptor_iostream_counted_string_write(") .", 3, iostr); return; } if(op == RASQAL_GRAPH_PATTERN_OPERATOR_SERVICE) { rasqal_graph_pattern* service_gp; /* LAQRS */ raptor_iostream_counted_string_write("SERVICE ", 8, iostr); rasqal_query_write_sparql_literal(wc, iostr, gp->origin); raptor_iostream_counted_string_write(" ", 1, iostr); service_gp = rasqal_graph_pattern_get_sub_graph_pattern(gp, 0); rasqal_query_write_sparql_graph_pattern(wc, iostr, service_gp, 0, indent); return; } if(op == RASQAL_GRAPH_PATTERN_OPERATOR_OPTIONAL || op == RASQAL_GRAPH_PATTERN_OPERATOR_GRAPH) { /* prefix verbs */ if(op == RASQAL_GRAPH_PATTERN_OPERATOR_OPTIONAL) raptor_iostream_counted_string_write("OPTIONAL ", 9, iostr); else { raptor_iostream_counted_string_write("GRAPH ", 6, iostr); rasqal_query_write_sparql_literal(wc, iostr, gp->origin); raptor_iostream_write_byte(' ', iostr); } } if(gp->op == RASQAL_GRAPH_PATTERN_OPERATOR_FILTER) want_braces = 0; if(want_braces) { raptor_iostream_counted_string_write("{\n", 2, iostr); indent += 2; } /* look for triples */ while(1) { rasqal_triple* t = rasqal_graph_pattern_get_triple(gp, triple_index); if(!t) break; rasqal_query_write_indent(iostr, indent); rasqal_query_write_sparql_triple(wc, iostr, t); raptor_iostream_write_byte('\n', iostr); triple_index++; } /* look for sub-graph patterns */ seq = rasqal_graph_pattern_get_sub_graph_pattern_sequence(gp); if(seq && raptor_sequence_size(seq) > 0) { for(gp_index = 0; 1; gp_index++) { rasqal_graph_pattern* sgp; sgp = rasqal_graph_pattern_get_sub_graph_pattern(gp, gp_index); if(!sgp) break; if(sgp->op == RASQAL_GRAPH_PATTERN_OPERATOR_FILTER) { filters_count++; continue; } if(!gp_index) rasqal_query_write_indent(iostr, indent); else { if(op == RASQAL_GRAPH_PATTERN_OPERATOR_UNION) /* infix verb */ raptor_iostream_counted_string_write(" UNION ", 7, iostr); else { /* must be prefix verb */ raptor_iostream_write_byte('\n', iostr); rasqal_query_write_indent(iostr, indent); } } rasqal_query_write_sparql_graph_pattern(wc, iostr, sgp, gp_index, indent); } raptor_iostream_write_byte('\n', iostr); } /* look for constraints */ if(filters_count > 0) { for(gp_index = 0; 1; gp_index++) { rasqal_graph_pattern* sgp; rasqal_expression* expr; sgp = rasqal_graph_pattern_get_sub_graph_pattern(gp, gp_index); if(!sgp) break; if(sgp->op != RASQAL_GRAPH_PATTERN_OPERATOR_FILTER) continue; expr = rasqal_graph_pattern_get_filter_expression(sgp); rasqal_query_write_indent(iostr, indent); raptor_iostream_counted_string_write("FILTER( ", 8, iostr); rasqal_query_write_sparql_expression(wc, iostr, expr); raptor_iostream_counted_string_write(" )\n", 3, iostr); } } if(want_braces) { indent -= 2; rasqal_query_write_indent(iostr, indent); raptor_iostream_write_byte('}', iostr); } }
int rasqal_query_write_sparql_20060406(raptor_iostream *iostr, rasqal_query* query, raptor_uri *base_uri) { int i; sparql_writer_context wc; int limit, offset; rasqal_query_verb verb; wc.world = query->world; wc.base_uri = NULL; wc.type_uri = raptor_new_uri_for_rdf_concept(query->world->raptor_world_ptr, (const unsigned char*)"type"); wc.nstack = raptor_new_namespaces(query->world->raptor_world_ptr, 1); if(base_uri) { raptor_iostream_counted_string_write("BASE ", 5, iostr); rasqal_query_write_sparql_uri(&wc, iostr, base_uri); raptor_iostream_write_byte('\n', iostr); /* from now on all URIs are relative to this */ wc.base_uri = raptor_uri_copy(base_uri); } for(i = 0; 1 ; i++) { raptor_namespace *nspace; rasqal_prefix* p = rasqal_query_get_prefix(query, i); if(!p) break; raptor_iostream_counted_string_write("PREFIX ", 7, iostr); if(p->prefix) raptor_iostream_string_write(p->prefix, iostr); raptor_iostream_counted_string_write(": ", 2, iostr); rasqal_query_write_sparql_uri(&wc, iostr, p->uri); raptor_iostream_write_byte('\n', iostr); /* Use this constructor so we copy a URI directly */ nspace = raptor_new_namespace_from_uri(wc.nstack, p->prefix, p->uri, i); raptor_namespaces_start_namespace(wc.nstack, nspace); } if(query->explain) raptor_iostream_counted_string_write("EXPLAIN ", 8, iostr); verb = query->verb; /* These terms are deprecated */ if(query->verb == RASQAL_QUERY_VERB_INSERT || query->verb == RASQAL_QUERY_VERB_DELETE) { verb = RASQAL_QUERY_VERB_UPDATE; } /* Write SPARQL 1.1 (Draft) Update forms */ if(verb == RASQAL_QUERY_VERB_UPDATE) { rasqal_update_operation* update; /* Write SPARQL Update */ for(i = 0; (update = rasqal_query_get_update_operation(query, i)); i++) { int is_always_2_args = (update->type >= RASQAL_UPDATE_TYPE_ADD && update->type <= RASQAL_UPDATE_TYPE_COPY); if(update->type == RASQAL_UPDATE_TYPE_UPDATE) { /* update operations: * WITH ... INSERT { template } DELETE { template } WHERE { template } * INSERT/DELETE { template } WHERE { template } * INSERT/DELETE DATA { triples } */ if(update->graph_uri) { raptor_iostream_counted_string_write("WITH ", 5, iostr); rasqal_query_write_sparql_uri(&wc, iostr, update->graph_uri); raptor_iostream_write_byte('\n', iostr); } if(update->delete_templates) { raptor_iostream_counted_string_write("DELETE ", 7, iostr); if(update->flags & RASQAL_UPDATE_FLAGS_DATA) raptor_iostream_counted_string_write("DATA ", 5, iostr); rasqal_query_write_sparql_triple_data(&wc, iostr, update->delete_templates, 0); raptor_iostream_write_byte('\n', iostr); } if(update->insert_templates) { raptor_iostream_counted_string_write("INSERT ", 7, iostr); if(update->flags & RASQAL_UPDATE_FLAGS_DATA) raptor_iostream_counted_string_write("DATA ", 5, iostr); rasqal_query_write_sparql_triple_data(&wc, iostr, update->insert_templates, 0); raptor_iostream_write_byte('\n', iostr); } if(update->where) { raptor_iostream_counted_string_write("WHERE ", 6, iostr); rasqal_query_write_sparql_graph_pattern(&wc, iostr, update->where, -1, 0); raptor_iostream_write_byte('\n', iostr); } } else { /* admin operations: * CLEAR GRAPH graph-uri | DEFAULT | NAMED | ALL * CREATE (SILENT) GRAPH graph-uri | DEFAULT | NAMED | ALL * DROP (SILENT) GRAPH graph-uri * LOAD (SILENT) doc-uri / LOAD (SILENT) doc-uri INTO GRAPH graph-uri * ADD (SILENT) GraphOrDefault TO GraphOrDefault * MOVE (SILENT) GraphOrDefault TO GraphOrDefault * COPY (SILENT) GraphOrDefault TO GraphOrDefault */ raptor_iostream_string_write(rasqal_update_type_label(update->type), iostr); if(update->flags & RASQAL_UPDATE_FLAGS_SILENT) raptor_iostream_counted_string_write(" SILENT", 7, iostr); if(is_always_2_args) { /* ADD, MOVE, COPY are always 2-arg admin operations */ rasqal_query_write_graphref(&wc, iostr, update->graph_uri, RASQAL_UPDATE_GRAPH_ONE); raptor_iostream_counted_string_write(" TO", 3, iostr); rasqal_query_write_graphref(&wc, iostr, update->document_uri, RASQAL_UPDATE_GRAPH_ONE); } else if(update->type == RASQAL_UPDATE_TYPE_LOAD) { /* LOAD is 1 or 2 URIs and first one never has a GRAPH prefix */ raptor_iostream_write_byte(' ', iostr); rasqal_query_write_sparql_uri(&wc, iostr, update->document_uri); if(update->graph_uri) { raptor_iostream_counted_string_write(" INTO", 5, iostr); rasqal_query_write_graphref(&wc, iostr, update->graph_uri, RASQAL_UPDATE_GRAPH_ONE); } } else { /* everything else is defined by update->applies; only * CLEAR and DROP may apply to >1 graph */ rasqal_query_write_graphref(&wc, iostr, update->graph_uri, update->applies); } raptor_iostream_write_byte('\n', iostr); } } goto tidy; } if(verb != RASQAL_QUERY_VERB_CONSTRUCT) raptor_iostream_string_write(rasqal_query_verb_as_string(query->verb), iostr); if(query->distinct) { if(query->distinct == 1) raptor_iostream_counted_string_write(" DISTINCT", 9, iostr); else raptor_iostream_counted_string_write(" REDUCED", 8, iostr); } if(query->wildcard) raptor_iostream_counted_string_write(" *", 2, iostr); else if(verb == RASQAL_QUERY_VERB_DESCRIBE) { raptor_sequence *lit_seq = query->describes; int count = raptor_sequence_size(lit_seq); for(i = 0; i < count; i++) { rasqal_literal* l = (rasqal_literal*)raptor_sequence_get_at(lit_seq, i); raptor_iostream_write_byte(' ', iostr); rasqal_query_write_sparql_literal(&wc, iostr, l); } } else if(verb == RASQAL_QUERY_VERB_SELECT) { rasqal_query_write_sparql_select(&wc, iostr, query->selects); } raptor_iostream_write_byte('\n', iostr); if(query->data_graphs) { for(i = 0; 1; i++) { rasqal_data_graph* dg = rasqal_query_get_data_graph(query, i); if(!dg) break; if(dg->flags & RASQAL_DATA_GRAPH_NAMED) continue; rasqal_query_write_data_format_comment(&wc, iostr, dg); raptor_iostream_counted_string_write("FROM ", 5, iostr); rasqal_query_write_sparql_uri(&wc, iostr, dg->uri); raptor_iostream_counted_string_write("\n", 1, iostr); } for(i = 0; 1; i++) { rasqal_data_graph* dg = rasqal_query_get_data_graph(query, i); if(!dg) break; if(!(dg->flags & RASQAL_DATA_GRAPH_NAMED)) continue; rasqal_query_write_data_format_comment(&wc, iostr, dg); raptor_iostream_counted_string_write("FROM NAMED ", 11, iostr); rasqal_query_write_sparql_uri(&wc, iostr, dg->name_uri); raptor_iostream_write_byte('\n', iostr); } } if(query->constructs) { raptor_iostream_string_write("CONSTRUCT {\n", iostr); for(i = 0; 1; i++) { rasqal_triple* t = rasqal_query_get_construct_triple(query, i); if(!t) break; raptor_iostream_counted_string_write(" ", 2, iostr); rasqal_query_write_sparql_triple(&wc, iostr, t); raptor_iostream_write_byte('\n', iostr); } raptor_iostream_counted_string_write("}\n", 2, iostr); } if(query->query_graph_pattern) { raptor_iostream_counted_string_write("WHERE ", 6, iostr); rasqal_query_write_sparql_graph_pattern(&wc, iostr, query->query_graph_pattern, -1, 0); raptor_iostream_write_byte('\n', iostr); } if(rasqal_query_get_group_conditions_sequence(query)) { raptor_iostream_counted_string_write("GROUP BY ", 9, iostr); for(i = 0; 1; i++) { rasqal_expression* expr = rasqal_query_get_group_condition(query, i); if(!expr) break; if(i > 0) raptor_iostream_write_byte(' ', iostr); rasqal_query_write_sparql_expression(&wc, iostr, expr); } raptor_iostream_write_byte('\n', iostr); } if(rasqal_query_get_having_conditions_sequence(query)) { raptor_iostream_counted_string_write("HAVING ", 7, iostr); for(i = 0; 1; i++) { rasqal_expression* expr = rasqal_query_get_having_condition(query, i); if(!expr) break; if(i > 0) raptor_iostream_write_byte(' ', iostr); rasqal_query_write_sparql_expression(&wc, iostr, expr); } raptor_iostream_write_byte('\n', iostr); } if(rasqal_query_get_order_conditions_sequence(query)) { raptor_iostream_counted_string_write("ORDER BY ", 9, iostr); for(i = 0; 1; i++) { rasqal_expression* expr = rasqal_query_get_order_condition(query, i); if(!expr) break; if(i > 0) raptor_iostream_write_byte(' ', iostr); rasqal_query_write_sparql_expression(&wc, iostr, expr); } raptor_iostream_write_byte('\n', iostr); } limit = rasqal_query_get_limit(query); offset = rasqal_query_get_offset(query); if(limit >= 0 || offset >= 0) { if(limit >= 0) { raptor_iostream_counted_string_write("LIMIT ", 7, iostr); raptor_iostream_decimal_write(limit, iostr); } if(offset >= 0) { if(limit) raptor_iostream_write_byte(' ', iostr); raptor_iostream_counted_string_write("OFFSET ", 8, iostr); raptor_iostream_decimal_write(offset, iostr); } raptor_iostream_write_byte('\n', iostr); } if(query->bindings) rasqal_write_sparql_bindings(&wc, iostr, query->bindings); tidy: raptor_free_uri(wc.type_uri); if(wc.base_uri) raptor_free_uri(wc.base_uri); raptor_free_namespaces(wc.nstack); return 0; }
static void rasqal_query_write_sparql_literal(sparql_writer_context *wc, raptor_iostream* iostr, rasqal_literal* l) { if(!l) { raptor_iostream_counted_string_write("null", 4, iostr); return; } switch(l->type) { case RASQAL_LITERAL_URI: rasqal_query_write_sparql_uri(wc, iostr, l->value.uri); break; case RASQAL_LITERAL_BLANK: raptor_iostream_counted_string_write("_:", 2, iostr); raptor_iostream_string_write(l->string, iostr); break; case RASQAL_LITERAL_STRING: raptor_iostream_write_byte('"', iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_write_byte('"', iostr); if(l->language) { raptor_iostream_write_byte('@', iostr); raptor_iostream_string_write(l->language, iostr); } if(l->datatype) { raptor_iostream_counted_string_write("^^", 2, iostr); rasqal_query_write_sparql_uri(wc, iostr, l->datatype); } break; case RASQAL_LITERAL_QNAME: raptor_iostream_counted_string_write("QNAME(", 6, iostr); raptor_iostream_counted_string_write(l->string, l->string_len, iostr); raptor_iostream_write_byte(')', iostr); break; case RASQAL_LITERAL_INTEGER: raptor_iostream_decimal_write(l->value.integer, iostr); break; case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_DECIMAL: raptor_iostream_counted_string_write(l->string, l->string_len, iostr); break; case RASQAL_LITERAL_VARIABLE: rasqal_query_write_sparql_variable(wc, iostr, l->value.variable); break; case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: if(1) { raptor_uri* dt_uri; raptor_iostream_write_byte('"', iostr); raptor_string_ntriples_write(l->string, l->string_len, '"', iostr); raptor_iostream_counted_string_write("\"^^", 3, iostr); if(l->type == RASQAL_LITERAL_UDT) dt_uri = l->datatype; else dt_uri = rasqal_xsd_datatype_type_to_uri(l->world, l->type); rasqal_query_write_sparql_uri(wc, iostr, dt_uri); } break; case RASQAL_LITERAL_UNKNOWN: case RASQAL_LITERAL_PATTERN: default: RASQAL_FATAL2("Literal type %d cannot be written as a SPARQL literal", l->type); } }
static void rasqal_query_write_sparql_expression(sparql_writer_context *wc, raptor_iostream* iostr, rasqal_expression* e) { int i; int count; switch(e->op) { case RASQAL_EXPR_CURRENT_DATETIME: case RASQAL_EXPR_NOW: case RASQAL_EXPR_RAND: rasqal_query_write_sparql_expression_op(wc, iostr, e); raptor_iostream_counted_string_write("()", 2, iostr); break; case RASQAL_EXPR_AND: case RASQAL_EXPR_OR: case RASQAL_EXPR_EQ: case RASQAL_EXPR_NEQ: case RASQAL_EXPR_LT: case RASQAL_EXPR_GT: case RASQAL_EXPR_LE: case RASQAL_EXPR_GE: case RASQAL_EXPR_PLUS: case RASQAL_EXPR_MINUS: case RASQAL_EXPR_STAR: case RASQAL_EXPR_SLASH: case RASQAL_EXPR_REM: case RASQAL_EXPR_STR_EQ: case RASQAL_EXPR_STR_NEQ: case RASQAL_EXPR_STRLANG: case RASQAL_EXPR_STRDT: case RASQAL_EXPR_STRSTARTS: case RASQAL_EXPR_STRENDS: case RASQAL_EXPR_CONTAINS: raptor_iostream_counted_string_write("( ", 2, iostr); rasqal_query_write_sparql_expression(wc, iostr, e->arg1); raptor_iostream_write_byte(' ', iostr); rasqal_query_write_sparql_expression_op(wc, iostr, e); raptor_iostream_write_byte(' ', iostr); rasqal_query_write_sparql_expression(wc, iostr, e->arg2); raptor_iostream_counted_string_write(" )", 2, iostr); break; case RASQAL_EXPR_BOUND: case RASQAL_EXPR_STR: case RASQAL_EXPR_LANG: case RASQAL_EXPR_DATATYPE: case RASQAL_EXPR_ISURI: case RASQAL_EXPR_ISBLANK: case RASQAL_EXPR_ISLITERAL: case RASQAL_EXPR_ORDER_COND_ASC: case RASQAL_EXPR_ORDER_COND_DESC: case RASQAL_EXPR_GROUP_COND_ASC: case RASQAL_EXPR_GROUP_COND_DESC: case RASQAL_EXPR_COUNT: case RASQAL_EXPR_SAMETERM: case RASQAL_EXPR_SUM: case RASQAL_EXPR_AVG: case RASQAL_EXPR_MIN: case RASQAL_EXPR_MAX: case RASQAL_EXPR_URI: case RASQAL_EXPR_IRI: case RASQAL_EXPR_BNODE: case RASQAL_EXPR_SAMPLE: case RASQAL_EXPR_ISNUMERIC: case RASQAL_EXPR_YEAR: case RASQAL_EXPR_MONTH: case RASQAL_EXPR_DAY: case RASQAL_EXPR_HOURS: case RASQAL_EXPR_MINUTES: case RASQAL_EXPR_SECONDS: case RASQAL_EXPR_TIMEZONE: case RASQAL_EXPR_FROM_UNIXTIME: case RASQAL_EXPR_TO_UNIXTIME: case RASQAL_EXPR_STRLEN: case RASQAL_EXPR_UCASE: case RASQAL_EXPR_LCASE: case RASQAL_EXPR_ENCODE_FOR_URI: case RASQAL_EXPR_TZ: case RASQAL_EXPR_ABS: case RASQAL_EXPR_ROUND: case RASQAL_EXPR_CEIL: case RASQAL_EXPR_FLOOR: case RASQAL_EXPR_MD5: case RASQAL_EXPR_SHA1: case RASQAL_EXPR_SHA224: case RASQAL_EXPR_SHA256: case RASQAL_EXPR_SHA384: case RASQAL_EXPR_SHA512: rasqal_query_write_sparql_expression_op(wc, iostr, e); raptor_iostream_counted_string_write("( ", 2, iostr); rasqal_query_write_sparql_expression(wc, iostr, e->arg1); raptor_iostream_counted_string_write(" )", 2, iostr); break; case RASQAL_EXPR_LANGMATCHES: case RASQAL_EXPR_REGEX: case RASQAL_EXPR_IF: case RASQAL_EXPR_SUBSTR: rasqal_query_write_sparql_expression_op(wc, iostr, e); raptor_iostream_counted_string_write("( ", 2, iostr); rasqal_query_write_sparql_expression(wc, iostr, e->arg1); raptor_iostream_counted_string_write(", ", 2, iostr); rasqal_query_write_sparql_expression(wc, iostr, e->arg2); if((e->op == RASQAL_EXPR_REGEX || e->op == RASQAL_EXPR_IF || e->op == RASQAL_EXPR_SUBSTR) && e->arg3) { raptor_iostream_counted_string_write(", ", 2, iostr); rasqal_query_write_sparql_expression(wc, iostr, e->arg3); } raptor_iostream_counted_string_write(" )", 2, iostr); break; case RASQAL_EXPR_TILDE: case RASQAL_EXPR_BANG: case RASQAL_EXPR_UMINUS: rasqal_query_write_sparql_expression_op(wc, iostr, e); raptor_iostream_counted_string_write("( ", 2, iostr); rasqal_query_write_sparql_expression(wc, iostr, e->arg1); raptor_iostream_counted_string_write(" )", 2, iostr); break; case RASQAL_EXPR_LITERAL: rasqal_query_write_sparql_literal(wc, iostr, e->literal); break; case RASQAL_EXPR_FUNCTION: raptor_uri_write(e->name, iostr); raptor_iostream_counted_string_write("( ", 2, iostr); if(e->flags & RASQAL_EXPR_FLAG_DISTINCT) raptor_iostream_counted_string_write(" DISTINCT ", 10, iostr); count = raptor_sequence_size(e->args); for(i = 0; i < count ; i++) { rasqal_expression* arg; arg = (rasqal_expression*)raptor_sequence_get_at(e->args, i); if(i > 0) raptor_iostream_counted_string_write(", ", 2, iostr); rasqal_query_write_sparql_expression(wc, iostr, arg); } raptor_iostream_counted_string_write(" )", 2, iostr); break; case RASQAL_EXPR_CAST: raptor_uri_write(e->name, iostr); raptor_iostream_counted_string_write("( ", 2, iostr); rasqal_query_write_sparql_expression(wc, iostr, e->arg1); raptor_iostream_counted_string_write(" )", 2, iostr); break; case RASQAL_EXPR_VARSTAR: raptor_iostream_write_byte('*', iostr); break; case RASQAL_EXPR_COALESCE: case RASQAL_EXPR_CONCAT: rasqal_query_write_sparql_expression_op(wc, iostr, e); raptor_iostream_counted_string_write("( ", 2, iostr); count = raptor_sequence_size(e->args); for(i = 0; i < count ; i++) { rasqal_expression* e2; e2 = (rasqal_expression*)raptor_sequence_get_at(e->args, i); if(i > 0) raptor_iostream_counted_string_write(", ", 2, iostr); rasqal_query_write_sparql_expression(wc, iostr, e2); } raptor_iostream_counted_string_write(" )", 2, iostr); break; case RASQAL_EXPR_GROUP_CONCAT: raptor_iostream_counted_string_write("GROUP_CONCAT( ", 14, iostr); if(e->flags & RASQAL_EXPR_FLAG_DISTINCT) raptor_iostream_counted_string_write("DISTINCT ", 9, iostr); count = raptor_sequence_size(e->args); for(i = 0; i < count ; i++) { rasqal_expression* arg; arg = (rasqal_expression*)raptor_sequence_get_at(e->args, i); if(i > 0) raptor_iostream_counted_string_write(", ", 2, iostr); rasqal_query_write_sparql_expression(wc, iostr, arg); } if(e->literal) { raptor_iostream_counted_string_write(" ; SEPARATOR = ", 15, iostr); rasqal_query_write_sparql_literal(wc, iostr, e->literal); } raptor_iostream_counted_string_write(" )", 2, iostr); break; case RASQAL_EXPR_IN: case RASQAL_EXPR_NOT_IN: rasqal_query_write_sparql_expression(wc, iostr, e->arg1); raptor_iostream_write_byte(' ', iostr); rasqal_query_write_sparql_expression_op(wc, iostr, e); raptor_iostream_counted_string_write(" (", 2, iostr); count = raptor_sequence_size(e->args); for(i = 0; i < count ; i++) { rasqal_expression* e2; e2 = (rasqal_expression*)raptor_sequence_get_at(e->args, i); if(i > 0) raptor_iostream_counted_string_write(", ", 2, iostr); rasqal_query_write_sparql_expression(wc, iostr, e2); } raptor_iostream_counted_string_write(" )", 2, iostr); break; case RASQAL_EXPR_UNKNOWN: case RASQAL_EXPR_STR_MATCH: case RASQAL_EXPR_STR_NMATCH: default: RASQAL_FATAL2("Expression op %d cannot be written as a SPARQL expresson", e->op); } }
static int rasqal_iostream_write_html_literal(rasqal_world* world, raptor_iostream *iostr, rasqal_literal* l) { if(!l) { raptor_iostream_counted_string_write("<span class=\"unbound\">", 22, iostr); raptor_iostream_counted_string_write("unbound", 7, iostr); } else { const unsigned char* str; size_t len; switch(l->type) { case RASQAL_LITERAL_URI: str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->value.uri, &len)); raptor_iostream_counted_string_write("<span class=\"uri\">", 18, iostr); raptor_iostream_counted_string_write("<a href=\"", 9, iostr); raptor_xml_escape_string_write(str, len, '"', iostr); raptor_iostream_counted_string_write("\">", 2, iostr); raptor_xml_escape_string_write(str, len, 0, iostr); raptor_iostream_counted_string_write("</a>", 4, iostr); break; case RASQAL_LITERAL_BLANK: raptor_iostream_counted_string_write("<span class=\"blank\">", 20, iostr); raptor_xml_escape_string_write(l->string, l->string_len, 0, iostr); break; case RASQAL_LITERAL_XSD_STRING: case RASQAL_LITERAL_BOOLEAN: case RASQAL_LITERAL_INTEGER: case RASQAL_LITERAL_DOUBLE: case RASQAL_LITERAL_STRING: case RASQAL_LITERAL_PATTERN: case RASQAL_LITERAL_QNAME: case RASQAL_LITERAL_FLOAT: case RASQAL_LITERAL_DECIMAL: case RASQAL_LITERAL_DATE: case RASQAL_LITERAL_DATETIME: case RASQAL_LITERAL_UDT: case RASQAL_LITERAL_INTEGER_SUBTYPE: raptor_iostream_counted_string_write("<span class=\"literal\">", 22, iostr); raptor_iostream_counted_string_write("<span class=\"value\"", 19, iostr); if(l->language) { str = RASQAL_GOOD_CAST(const unsigned char*, l->language); raptor_iostream_counted_string_write(" xml:lang=\"", 11, iostr); raptor_xml_escape_string_write(str, strlen(l->language), '"', iostr); raptor_iostream_write_byte('"', iostr); } raptor_iostream_write_byte('>', iostr); raptor_xml_escape_string_write(l->string, l->string_len, 0, iostr); raptor_iostream_counted_string_write("</span>", 7, iostr); if(l->datatype) { raptor_iostream_counted_string_write("^^<<span class=\"datatype\">", 29, iostr); str = RASQAL_GOOD_CAST(const unsigned char*, raptor_uri_as_counted_string(l->datatype, &len)); raptor_xml_escape_string_write(str, len, 0, iostr); raptor_iostream_counted_string_write("</span>>", 11, iostr); } break; case RASQAL_LITERAL_VARIABLE: return rasqal_iostream_write_html_literal(world, iostr, l->value.variable->value); case RASQAL_LITERAL_UNKNOWN: default: rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Cannot turn literal type %d into HTML", l->type); return 1; }
/* * rasqal_query_results_write_turtle: * @iostr: #raptor_iostream to write the query to * @results: #rasqal_query_results query results format * @base_uri: #raptor_uri base URI of the output format * * Write a Turtle version of the query results format to an * iostream in a format - INTERNAL. * * If the writing succeeds, the query results will be exhausted. * * Return value: non-0 on failure **/ static int rasqal_query_results_write_turtle(raptor_iostream *iostr, rasqal_query_results* results, raptor_uri *base_uri) { rasqal_world* world = rasqal_query_results_get_world(results); int i; int row_semicolon; int column_semicolon = 0; int size; if(!rasqal_query_results_is_bindings(results)) { rasqal_log_error_simple(world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Can only write Turtle format for variable binding results"); return 1; } raptor_iostream_string_write("@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .\n", iostr); raptor_iostream_string_write("@prefix rs: <http://www.w3.org/2001/sw/DataAccess/tests/result-set#> .\n", iostr); raptor_iostream_string_write("@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .\n", iostr); raptor_iostream_write_byte('\n', iostr); raptor_iostream_counted_string_write("[] rdf:type rs:ResultSet ;\n", 35, iostr); /* Variable Binding Results */ for(i = 0; 1; i++) { const unsigned char *name; name = rasqal_query_results_get_binding_name(results, i); if(!name) break; raptor_iostream_counted_string_write(" rs:resultVariable \"", 26, iostr); raptor_iostream_string_write(name, iostr); raptor_iostream_counted_string_write("\" ;\n", 4, iostr); } size = rasqal_query_results_get_bindings_count(results); row_semicolon = 0; while(!rasqal_query_results_finished(results)) { if(row_semicolon) raptor_iostream_counted_string_write(" ;\n", 3, iostr); /* Result row */ raptor_iostream_counted_string_write(" rs:solution [ ", 22, iostr); column_semicolon = 0; for(i = 0; i < size; i++) { const unsigned char *name; rasqal_literal *l; name = rasqal_query_results_get_binding_name(results, i); l = rasqal_query_results_get_binding_value(results, i); if(column_semicolon) raptor_iostream_counted_string_write("; \n ", 25, iostr); /* binding */ raptor_iostream_counted_string_write("rs:binding [ ", 16, iostr); /* only emit rs:value and rs:variable triples if there is a value */ if(l) { raptor_iostream_counted_string_write("rs:variable \"", 15, iostr); raptor_iostream_string_write(name, iostr); raptor_iostream_counted_string_write("\" ;\n rs:value ", 56, iostr); rasqal_literal_write_turtle(l, iostr); raptor_iostream_counted_string_write("\n ] ", 39, iostr); column_semicolon = 1; } } /* End Result Row */ raptor_iostream_counted_string_write("\n ]", 8, iostr); row_semicolon = 1; rasqal_query_results_next(results); } raptor_iostream_counted_string_write(" .\n", 3, iostr); return 0; }
/** * raptor_string_python_write: * @string: UTF-8 string to write * @len: length of UTF-8 string * @delim: Terminating delimiter character for string (such as " or >) * or \0 for no escaping. * @flags: flags 0=N-Triples mode, 1=Turtle (allow raw UTF-8), 2=Turtle long string (allow raw UTF-8), 3=JSON * @iostr: #raptor_iostream to write to * * Write a UTF-8 string using Python-style escapes (N-Triples, Turtle, JSON) to an iostream. * * Return value: non-0 on failure such as bad UTF-8 encoding. **/ int raptor_string_python_write(const unsigned char *string, size_t len, const char delim, int flags, raptor_iostream *iostr) { unsigned char c; int unichar_len; raptor_unichar unichar; if(flags < 0 || flags > 3) return 1; for(; (c=*string); string++, len--) { if((delim && c == delim && (delim == '\'' || delim == '"')) || c == '\\') { raptor_iostream_write_byte('\\', iostr); raptor_iostream_write_byte(c, iostr); continue; } if(delim && c == delim) { raptor_iostream_counted_string_write("\\u", 2, iostr); raptor_iostream_hexadecimal_write(c, 4, iostr); continue; } if(flags != 2) { /* N-Triples, Turtle or JSON */ /* Note: NTriples is ASCII */ if(c == 0x09) { raptor_iostream_counted_string_write("\\t", 2, iostr); continue; } else if((flags == 3) && c == 0x08) { /* JSON has \b for backspace */ raptor_iostream_counted_string_write("\\b", 2, iostr); continue; } else if(c == 0x0a) { raptor_iostream_counted_string_write("\\n", 2, iostr); continue; } else if((flags == 3) && c == 0x0b) { /* JSON has \f for formfeed */ raptor_iostream_counted_string_write("\\f", 2, iostr); continue; } else if(c == 0x0d) { raptor_iostream_counted_string_write("\\r", 2, iostr); continue; } else if(c < 0x20|| c == 0x7f) { raptor_iostream_counted_string_write("\\u", 2, iostr); raptor_iostream_hexadecimal_write(c, 4, iostr); continue; } else if(c < 0x80) { raptor_iostream_write_byte(c, iostr); continue; } } else if(c < 0x80) { /* Turtle long string has no escapes except delim */ raptor_iostream_write_byte(c, iostr); continue; } /* It is unicode */ unichar_len = raptor_unicode_utf8_string_get_char(string, len, NULL); if(unichar_len < 0 || unichar_len > (int)len) /* UTF-8 encoding had an error or ended in the middle of a string */ return 1; if(flags >= 1 && flags <= 3) { /* Turtle and JSON are UTF-8 - no need to escape */ raptor_iostream_counted_string_write(string, unichar_len, iostr); } else { unichar_len = raptor_unicode_utf8_string_get_char(string, len, &unichar); if(unichar < 0x10000) { raptor_iostream_counted_string_write("\\u", 2, iostr); raptor_iostream_hexadecimal_write(unichar, 4, iostr); } else { raptor_iostream_counted_string_write("\\U", 2, iostr); raptor_iostream_hexadecimal_write(unichar, 8, iostr); } } unichar_len--; /* since loop does len-- */ string += unichar_len; len -= unichar_len; } return 0; }
/** * raptor_turtle_writer_raw_counted: * @turtle_writer: Turtle writer object * @s: raw string to write * @len: length of string * * Write a counted string to the Turtle writer verbatim. * **/ void raptor_turtle_writer_raw_counted(raptor_turtle_writer* turtle_writer, const unsigned char *s, unsigned int len) { raptor_iostream_counted_string_write(s, len, turtle_writer->iostr); }
/** * raptor_xml_element_write: * @element: XML element to format * @nstack: Namespace stack context to use in formatting * @is_empty: non-0 if element is empty * @is_end: non-0 if this is an end element (else is a start element) * @depth: XML element depth * @iostr: iostream object * * Write a formatted XML element to a #raptor_iostream * * Return value: non-0 on failure */ int raptor_xml_element_write(raptor_xml_element *element, raptor_namespace_stack *nstack, int is_empty, int is_end, int depth, raptor_iostream* iostr) { struct nsd *nspace_declarations = NULL; size_t nspace_declarations_count = 0; unsigned int i; /* max is 1 per element and 1 for each attribute + size of declared */ if(nstack) { int nspace_max_count = element->attribute_count+1; if(element->declared_nspaces) nspace_max_count += raptor_sequence_size(element->declared_nspaces); nspace_declarations = RAPTOR_CALLOC(struct nsd*, nspace_max_count, sizeof(struct nsd)); } if(element->name->nspace) { if(!is_end && nstack && !raptor_namespaces_namespace_in_scope(nstack, element->name->nspace)) { nspace_declarations[0].declaration= raptor_namespace_format_as_xml(element->name->nspace, &nspace_declarations[0].length); nspace_declarations[0].nspace = element->name->nspace; nspace_declarations_count++; } } if(!is_end && element->attributes) { for(i = 0; i < element->attribute_count; i++) { /* qname */ if(element->attributes[i]->nspace) { if(nstack && !raptor_namespaces_namespace_in_scope(nstack, element->attributes[i]->nspace) && element->attributes[i]->nspace != element->name->nspace) { /* not in scope and not same as element (so already going to be declared)*/ unsigned int j; int declare_me = 1; /* check it wasn't an earlier declaration too */ for(j = 0; j < nspace_declarations_count; j++) if(nspace_declarations[j].nspace == element->attributes[j]->nspace) { declare_me = 0; break; } if(declare_me) { nspace_declarations[nspace_declarations_count].declaration= raptor_namespace_format_as_xml(element->attributes[i]->nspace, &nspace_declarations[nspace_declarations_count].length); nspace_declarations[nspace_declarations_count].nspace = element->attributes[i]->nspace; nspace_declarations_count++; } } } } } if(!is_end && nstack && element->declared_nspaces && raptor_sequence_size(element->declared_nspaces) > 0) { for(i = 0; i< (unsigned int)raptor_sequence_size(element->declared_nspaces); i++) { raptor_namespace* nspace = (raptor_namespace*)raptor_sequence_get_at(element->declared_nspaces, i); unsigned int j; int declare_me = 1; /* check it wasn't an earlier declaration too */ for(j = 0; j < nspace_declarations_count; j++) if(nspace_declarations[j].nspace == nspace) { declare_me = 0; break; } if(declare_me) { nspace_declarations[nspace_declarations_count].declaration= raptor_namespace_format_as_xml(nspace, &nspace_declarations[nspace_declarations_count].length); nspace_declarations[nspace_declarations_count].nspace = nspace; nspace_declarations_count++; } } } raptor_iostream_write_byte('<', iostr); if(is_end) raptor_iostream_write_byte('/', iostr); if(element->name->nspace && element->name->nspace->prefix_length > 0) { raptor_iostream_counted_string_write((const char*)element->name->nspace->prefix, element->name->nspace->prefix_length, iostr); raptor_iostream_write_byte(':', iostr); } raptor_iostream_counted_string_write((const char*)element->name->local_name, element->name->local_name_length, iostr); /* declare namespaces */ if(nspace_declarations_count) { /* sort them into the canonical order */ qsort((void*)nspace_declarations, nspace_declarations_count, sizeof(struct nsd), raptor_nsd_compare); /* add them */ for(i = 0; i < nspace_declarations_count; i++) { raptor_iostream_write_byte(' ', iostr); raptor_iostream_counted_string_write((const char*)nspace_declarations[i].declaration, nspace_declarations[i].length, iostr); RAPTOR_FREE(char*, nspace_declarations[i].declaration); nspace_declarations[i].declaration = NULL; raptor_namespace_stack_start_namespace(nstack, (raptor_namespace*)nspace_declarations[i].nspace, depth); } } if(!is_end && element->attributes) { for(i = 0; i < element->attribute_count; i++) { raptor_iostream_write_byte(' ', iostr); if(element->attributes[i]->nspace && element->attributes[i]->nspace->prefix_length > 0) { raptor_iostream_counted_string_write((char*)element->attributes[i]->nspace->prefix, element->attributes[i]->nspace->prefix_length, iostr); raptor_iostream_write_byte(':', iostr); } raptor_iostream_counted_string_write((const char*)element->attributes[i]->local_name, element->attributes[i]->local_name_length, iostr); raptor_iostream_counted_string_write("=\"", 2, iostr); raptor_xml_escape_string_write(element->attributes[i]->value, element->attributes[i]->value_length, '"', iostr); raptor_iostream_write_byte('"', iostr); } } if(is_empty) raptor_iostream_write_byte('/', iostr); raptor_iostream_write_byte('>', iostr); if(nstack) RAPTOR_FREE(stringarray, nspace_declarations); return 0; }