コード例 #1
0
ファイル: rasqal_rowsource_graph.c プロジェクト: kasei/rasqal
static int
rasqal_graph_next_dg(rasqal_graph_rowsource_context *con) 
{
  rasqal_query *query = con->rowsource->query;
  rasqal_data_graph *dg;

  con->finished = 0;

  while(1) {
    rasqal_literal *o;

    con->dg_offset++;
    dg = rasqal_query_get_data_graph(query, con->dg_offset);
    if(!dg) {
      con->finished = 1;
      break;
    }
    
    if(!dg->name_uri)
      continue;
    
    o = rasqal_new_uri_literal(query->world, raptor_uri_copy(dg->name_uri));
    if(!o) {
      RASQAL_DEBUG1("Failed to create new URI literal\n");
      con->finished = 1;
      break;
    }

    RASQAL_DEBUG2("Using data graph URI literal <%s>\n",
                  rasqal_literal_as_string(o));
    
    rasqal_rowsource_set_origin(con->rowsource, o);

    /* this passes ownership of o to con->var */
    rasqal_variable_set_value(con->var, o);
      
    break;
  }

  return con->finished;
}
コード例 #2
0
ファイル: rasqal_query_write.c プロジェクト: egh/rasqal
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;
}