import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
private void evaluate(QueryType type, ParsedQuery query,
		TupleQueryResultHandler handler) {
	if (type.equals(QueryType.SENSOR_OBSERVATION)) {
		evaluate(query, QueryFactory.createSensorObservationQuery(query),
				handler);
		return;
	}
	if (type.equals(QueryType.DATASET_OBSERVATION)) {
		evaluate(query, QueryFactory.createDatasetObservationQuery(query),
				handler);
		return;
	}

	if (log.isLoggable(Level.SEVERE))
		log.severe("Failed to deterine observation query type, sensor or dataset [query = "
				+ query + "]");
}
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
/**
 * @param args
 * @throws Exception 
 */
public static void main(String[] args) throws Exception {
	UnmanagedRepositoryFactory factory = new UnmanagedRepositoryFactory();
	Repository rep = factory.createRepository(new File(args.length > 1 ? args[1] : "owlim.ttl"));
	rep.initialize();
	try {
		RepositoryConnection conn = rep.getConnection();
		String queryString = FileUtils.readFileToString(new File(args[0]).getAbsoluteFile());
		Constructor<TupleQueryResultHandler> wrapperFactory = null;
		QueryResultListener.Feed dataFeed = new RepositoryFeed(conn, wrapperFactory, queryString);
		new TempAliasCache(dataFeed);
	}
	finally {
		rep.shutDown();
	}
}
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
public void testNamespaceUsage() throws Exception {
    RepositoryConnection conn = repository.getConnection();
    conn.setNamespace("lit", litdupsNS);
    URI loadPerc = vf.createURI(litdupsNS, "loadPerc");
    final URI uri1 = vf.createURI(litdupsNS, "uri1");
    conn.add(cpu, loadPerc, uri1);
    conn.commit();

    String query = "PREFIX lit: <" + litdupsNS + ">\n" +
            "select * where {lit:cpu lit:loadPerc ?o.}";
    TupleQuery tupleQuery = conn.prepareTupleQuery(QueryLanguage.SPARQL, query);
    tupleQuery.evaluate(new TupleQueryResultHandler() {

        @Override
        public void startQueryResult(List<String> strings) throws TupleQueryResultHandlerException {
        }

        @Override
        public void endQueryResult() throws TupleQueryResultHandlerException {

        }

        @Override
        public void handleSolution(BindingSet bindingSet) throws TupleQueryResultHandlerException {
            assertTrue(uri1.toString().equals(bindingSet.getBinding("o").getValue().stringValue()));
        }

        @Override
        public void handleBoolean(boolean paramBoolean) throws QueryResultHandlerException {
        }

        @Override
        public void handleLinks(List<String> paramList) throws QueryResultHandlerException {
        }
    });
    conn.close();
}
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
@Override
public void setUp() throws Exception {
    super.setUp();
    dao = new AccumuloRyaDAO();
    connector = new MockInstance().getConnector("", new PasswordToken(""));
    dao.setConnector(connector);
    conf = new AccumuloRdfConfiguration();
    conf.setInfer(true);
    dao.setConf(conf);
    dao.init();
    store = new RdfCloudTripleStore();
    store.setConf(conf);
    store.setRyaDAO(dao);
    inferenceEngine = new InferenceEngine();
    inferenceEngine.setRyaDAO(dao);
    store.setInferenceEngine(inferenceEngine);
    inferenceEngine.refreshGraph();
    store.initialize();
    repository = new SailRepository(store);
    conn = repository.getConnection();
    solutions = new LinkedList<>();
    resultHandler = new TupleQueryResultHandler() {
        @Override
        public void endQueryResult() throws TupleQueryResultHandlerException { }
        @Override
        public void handleBoolean(final boolean value) throws QueryResultHandlerException { }
        @Override
        public void handleLinks(final List<String> linkUrls) throws QueryResultHandlerException { }
        @Override
        public void handleSolution(final BindingSet bindingSet) throws TupleQueryResultHandlerException {
            if (bindingSet != null && bindingSet.iterator().hasNext()) {
                solutions.add(bindingSet);
            }
        }
        @Override
        public void startQueryResult(final List<String> bindingNames) throws TupleQueryResultHandlerException {
            solutions.clear();
        }
    };
}
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
@Override
public void evaluate(TupleQueryResultHandler handler) {
	try {
		getTupleQuery().evaluate(handler);
	} catch (QueryEvaluationException | RepositoryException
			| MalformedQueryException | TupleQueryResultHandlerException e) {
		throw new RuntimeException(e);
	}
}
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
public CountingTupleQueryResultHandlerWrapper(final TupleQueryResultHandler indir){
    this.indir = indir;
}
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
@Override
public void evaluate(TupleQueryResultHandler handler) {
	throw new UnsupportedOperationException(
			"Query evaluation with result handler not supported");
}
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
@Override
public void evaluate(TupleQueryResultHandler handler) {
	throw new UnsupportedOperationException();
}
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
public void setTupleQueryResultHandler(TupleQueryResultHandler handler) {
  this.handler = handler;
}
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
@Override
public void evaluate(TupleQueryResultHandler handler) throws QueryEvaluationException, TupleQueryResultHandlerException
{
   throw new UnsupportedOperationException("Operation is not supported"); //$NON-NLS-1$
}
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
public RepositoryFeed(RepositoryConnection conn, Constructor<TupleQueryResultHandler> wrapperFactory, String queryString) {			
	this.conn = conn;
	this.wrapperFactory = wrapperFactory;
	this.query = queryString;
}
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
/**
 * Sets the TupleQueryResultHandler that will handle the parsed query result data.
 */
public void setTupleQueryResultHandler(TupleQueryResultHandler handler);
 

import org.openrdf.query.TupleQueryResultHandler; //导入依赖的package包/类
public void evaluate(TupleQueryResultHandler handler);