import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
public static TupleQueryResultWriter newSparqlTupleWriter(final TupleQueryResultFormat format,
        final OutputStream stream) {

    final TupleQueryResultWriter writer = QueryResultIO.createWriter(format, stream);

    final WriterConfig config = writer.getWriterConfig();
    if (format.equals(TupleQueryResultFormat.JSON)) {
        config.set(BasicWriterSettings.PRETTY_PRINT, true);
        config.set(BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL, true);
        config.set(BasicWriterSettings.RDF_LANGSTRING_TO_LANG_LITERAL, true);

    } else if (format.equals(TupleQueryResultFormat.SPARQL)) {
        config.set(BasicWriterSettings.PRETTY_PRINT, true);
        config.set(BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL, true);
        config.set(BasicWriterSettings.RDF_LANGSTRING_TO_LANG_LITERAL, true);
        config.set(BasicQueryWriterSettings.ADD_SESAME_QNAME, false);
    }

    return writer;
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
@Override
protected void doQuery(QueryDefinition query, WriterConfig config,
		RepositoryConnection cxn, OutputStream os) throws Exception {
	final TupleQuery sailTupleQuery = cxn 
			.prepareTupleQuery(query.getQueryLanguage(), query.getQuery(),
					config.getBaseUri());
	final TupleQueryResultFormat format = TupleQueryResultWriterRegistry
			.getInstance().getFileFormatForMIMEType(config.getContentType());
	final TupleQueryResultWriter w = TupleQueryResultWriterRegistry
			.getInstance().get(format).getWriter(os);
	sailTupleQuery.evaluate(w);
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
private void renderTupleQuery(Query query, TupleQueryResultWriter writer) throws QueryEvaluationException, TupleQueryResultHandlerException {
    TupleQueryResult tupleQueryResult = ((TupleQuery) query).evaluate();
    writer.startQueryResult(tupleQueryResult.getBindingNames());
    while (tupleQueryResult.hasNext()) {
        writer.handleSolution(tupleQueryResult.next());
    }
    writer.endQueryResult();
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
public static long writeSparqlTuples(final TupleQueryResultFormat format,
        final OutputStream out, final Stream<? extends BindingSet> stream) {

    final TupleQueryResultWriter writer = RDFUtil.newSparqlTupleWriter(format, out);

    try {
        final AtomicLong result = new AtomicLong();
        stream.toHandler(new Handler<BindingSet>() {

            private boolean started = false;

            private long count = 0L;

            @Override
            public void handle(final BindingSet bindings) throws QueryResultHandlerException {
                if (!this.started) {
                    @SuppressWarnings("unchecked")
                    final List<String> variables = (List<String>) stream.getProperty(
                            PROPERTY_VARIABLES, Object.class);
                    writer.startDocument();
                    writer.startHeader();
                    writer.startQueryResult(variables);
                    this.started = true;
                }
                if (bindings != null) {
                    writer.handleSolution(bindings);
                    ++this.count;
                } else if (this.started) {
                    writer.endQueryResult();
                    result.set(this.count);
                }
            }

        });
        return result.get();

    } catch (final Exception ex) {
        throw Throwables.propagate(ex);

    } finally {
        Util.closeQuietly(stream);
    }
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
public static TupleQueryResultWriter createstSPARQLQueryResultWriter(Format format,
    OutputStream out) {
  TupleQueryResultWriter writer = null;

  switch (format) {
    case DEFAULT:
      writer = tsv.getWriter(out);
      break;

    case XML:
      writer = xml.getWriter(out);
      break;

    case KML:
      writer = kml.getWriter(out);
      break;

    case KMZ:
      writer = kmz.getWriter(out);
      break;

    case GEOJSON:
      writer = geojson.getWriter(out);
      break;

    case EXP:
      // TODO: add
      break;

    case HTML:
      writer = html.getWriter(out);
      break;

    case TSV:
      writer = tsv.getWriter(out);
      break;

    case SESAME_XML:
      writer = QueryResultIO.createWriter(TupleQueryResultFormat.SPARQL, out);
      break;

    case SESAME_BINARY:
      writer = QueryResultIO.createWriter(TupleQueryResultFormat.BINARY, out);
      break;

    case SESAME_JSON:
      writer = QueryResultIO.createWriter(TupleQueryResultFormat.JSON, out);
      break;

    case SESAME_CSV:
      writer = QueryResultIO.createWriter(TupleQueryResultFormat.CSV, out);
      break;

    case SESAME_TSV:
      writer = QueryResultIO.createWriter(TupleQueryResultFormat.TSV, out);
      break;

    default:
      // return NULL
  }

  return writer;
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
public Object query(String queryString, Format resultsFormat, SailRepositoryConnection con,
    OutputStream out) throws MalformedQueryException, QueryEvaluationException, IOException,
    TupleQueryResultHandlerException {
  boolean status = true;

  logger.info("[Strabon.query] Executing query: {}", queryString);

  // check for null stream
  if (out == null) {
    logger.error("[Strabon.query] Cannot write to null stream.");

    return false;
  }

  TupleQuery tupleQuery = null;
  try {
    tupleQuery = con.prepareTupleQuery(QueryLanguage.SPARQL, queryString);

  } catch (RepositoryException e) {
    logger.error("[Strabon.query] Error in preparing tuple query.", e);
    status = false;
  }

  if (logger.isDebugEnabled()) {
    logger.debug("Serializing results ({})", resultsFormat.name());
  }

  TupleQueryResult result = null;
  switch (resultsFormat) {
    case EXP:
      long results = 0;

      long t1 = System.nanoTime();
      result = tupleQuery.evaluate();
      long t2 = System.nanoTime();

      while (result.hasNext()) {
        results++;
        result.next();
      }

      long t3 = System.nanoTime();

      logger.info((t2 - t1) + " + " + (t3 - t2) + " = " + (t3 - t1) + " | " + results);
      return new long[] {t2 - t1, t3 - t2, t3 - t1, results};
      // break;

    case TUQU:

      return tupleQuery;
      // break;
    case PIECHART:
      return tupleQuery.evaluate();

    case AREACHART:
      return tupleQuery.evaluate();

    case COLUMNCHART:
      return tupleQuery.evaluate();

    default:
      // get the writer for the specified format
      TupleQueryResultWriter resultWriter =
          stSPARQLQueryResultToFormatAdapter.createstSPARQLQueryResultWriter(resultsFormat, out);

      // check for null format
      if (resultWriter == null) {
        logger.error("[Strabon.query] Invalid format.");
        return false;
      }

      tupleQuery.evaluate(resultWriter);
  }

  return status;
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
@Override
public TupleQueryResultWriter getWriter(OutputStream out) {
  return new stSPARQLResultsGeoJSONWriter(out);
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
@Override
public TupleQueryResultWriter getWriter(OutputStream out) {
  return new stSPARQLResultsKMLWriter(out);
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
@Override
public TupleQueryResultWriter getWriter(OutputStream out) {
  return new stSPARQLResultsKMZWriter(out);
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
@Override
public TupleQueryResultWriter getWriter(OutputStream out) {
  return new stSPARQLResultsXMLWriter(out);
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
@Override
public TupleQueryResultWriter getWriter(OutputStream out) {
  return new stSPARQLResultsTSVWriter(out);
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
@Override
public TupleQueryResultWriter getWriter(OutputStream out) {
  return new stSPARQLResultsHTMLWriter(out);
}
 

import org.openrdf.query.resultio.TupleQueryResultWriter; //导入依赖的package包/类
/**
 * Returns a new instance of SPARQLResultsHTMLWriter.
 */
@Override
public TupleQueryResultWriter getWriter(OutputStream out) {
	return new SPARQLResultsHTMLWriter(out);
}