import com.hp.hpl.jena.sparql.engine.Plan; //导入依赖的package包/类
public BindingQueryPlan prepareBindings(GraphQuery q, Node[] variables) {   
	this.variables = variables;
	this.indexes = new HashMap<Node,Integer>();
	for (int i = 0; i < variables.length; i++) {
		indexes.put(variables[i], new Integer(i));
	}
	BasicPattern pattern = new BasicPattern();
	for (Triple t: q.getPattern()) {
		pattern.add(t);
	}
	Plan plan = QueryEngineD2RQ.getFactory().create(new OpBGP(pattern), dataset, null, null);
	final ExtendedIterator<Domain> queryIterator = new Map1Iterator<Binding,Domain>(new BindingToDomain(), plan.iterator());
	return new BindingQueryPlan() {
		public ExtendedIterator<Domain> executeBindings() {
			return queryIterator;
		}
	};
}
 

import com.hp.hpl.jena.sparql.engine.Plan; //导入依赖的package包/类
public BindingQueryPlan prepareBindings(Query q, Node[] variables) {   
	this.variables = variables;
	this.indexes = new HashMap<Node,Integer>();
	for (int i = 0; i < variables.length; i++) {
		indexes.put(variables[i], new Integer(i));
	}
	BasicPattern pattern = new BasicPattern();
	for (Triple t: q.getPattern()) {
		pattern.add(t);
	}
	Plan plan = QueryEngineD2RQ.getFactory().create(new OpBGP(pattern), dataset, null, null);
	final ExtendedIterator<Domain> queryIterator = new Map1Iterator<Binding,Domain>(new BindingToDomain(), plan.iterator());
	return new BindingQueryPlan() {
		public ExtendedIterator<Domain> executeBindings() {
			return queryIterator;
		}
	};
}
 

import com.hp.hpl.jena.sparql.engine.Plan; //导入依赖的package包/类
/**
 * <p>Method that prepares the bindings for a query plan</p>
 * @param q - the input query
 * @param variables - the variables in the given query
 * @return a binding query plan
 * 
 * @see de.fuberlin.wiwiss.d2rq.D2RQQueryHandler#prepareBindings(Query, Node[])
 */
@SuppressWarnings("unchecked")
public BindingQueryPlan prepareBindings(Query q, Node[] variables) 
{   
	this.variables = variables;
	this.indexes = new HashMap();
	for (int i = 0; i < variables.length; i++) { indexes.put(variables[i], new Integer(i)); }
	BasicPattern pattern = new BasicPattern();
	Iterator it = q.getPattern().iterator();
	while (it.hasNext()) 
	{
		Triple t = (Triple) it.next();
		pattern.add(t);
	}
	Plan plan = QueryEngineD2RQ.getFactory().create(new OpBGP(pattern), dataset, null, null);
	final ExtendedIterator queryIterator = new Map1Iterator(new BindingToDomain(), plan.iterator());
	return new BindingQueryPlan() 
	{
		public ExtendedIterator executeBindings() { return queryIterator; }
	};
}
 

import com.hp.hpl.jena.sparql.engine.Plan; //导入依赖的package包/类
static void execute(DatasetGraph dsg, Op op, Context context) {
    /*
    Algebra.exec(op, dsg)
    ==>
    QueryEngineFactory f = QueryEngineRegistry.findFactory(op, ds, null) ;
    Plan plan = f.create(op, ds, BindingRoot.create(), null) ;
    return plan.iterator() ;
    */
    
    context = Context.setupContext(context, dsg) ;
    OpExecutorFactory factory = QC.getFactory(context) ;
    if ( factory == null )
        factory = OpExecutor.stdFactory ;
    
    ExecutionContext execCxt = new ExecutionContext(context, dsg.getDefaultGraph(), dsg, factory) ;
    QueryIterator qIterRoot = OpExecutor.createRootQueryIterator(execCxt) ; 
    QueryIterator qIterPlan = QC.execute(op, qIterRoot, execCxt) ;
    Plan plan = new PlanOp(op, null, qIterPlan) ;
    runPlan(plan) ;
    
    /*
    Query query = null ;
    Dataset dataset = null ;
    QueryEngineFactory qefactory = null ;
    @SuppressWarnings("resource")
    QueryExecutionBase queryExecutionBase = new QueryExecutionBase(query, dataset, context, qefactory)  ;
    */
}
 

import com.hp.hpl.jena.sparql.engine.Plan; //导入依赖的package包/类
private static void runPlan(Plan plan) {
    //QueryExecUtils.execute(op, dsg)
    List<String> vars = null ;
    ResultsFormat outputFormat = ResultsFormat.FMT_TEXT ;
    
    Op op = plan.getOp();
    if ( op instanceof OpProject )
        vars = Var.varNames(((OpProject)op).getVars()) ;
    else
        vars = Var.varNames(OpVars.visibleVars(op)) ;

    ResultSet results = ResultSetFactory.create(plan.iterator(), vars) ;
    QueryExecUtils.outputResultSet(results, null, outputFormat) ;
}
 

import com.hp.hpl.jena.sparql.engine.Plan; //导入依赖的package包/类
@Override
public Plan create(Query query, DatasetGraph dataset, Binding input, Context context)
{
    QueryEngineMain engine = new QueryEngineMain2(query, dataset, input, context) ;
    QC.setFactory(context, OpExecutorRowsMain.factoryRowsMain) ;
    return engine.getPlan() ;
}
 

import com.hp.hpl.jena.sparql.engine.Plan; //导入依赖的package包/类
@Override
public Plan create(Query query, DatasetGraph dataset, Binding input, Context context)
{
    // This is the usual route.
    DatasetGraphTDB dsgtdb = dsgToQuery(dataset) ;
    setup(dsgtdb, context) ;
    QueryEngineQuackTDB engine = new QueryEngineQuackTDB(query, dsgtdb, input, context) ;
    return engine.getPlan() ;
}
 

import com.hp.hpl.jena.sparql.engine.Plan; //导入依赖的package包/类
public Plan create(Query query, DatasetGraph dataset,
		Binding inputBinding, Context context) {
	return new QueryEngineD2RQ((GraphD2RQ) dataset.getDefaultGraph(),
			query, context).getPlan();
}
 

import com.hp.hpl.jena.sparql.engine.Plan; //导入依赖的package包/类
@Override
public Plan create(Query query, DatasetGraph dataset, Binding binding, Context context)
{
    QueryEngineRemediatorQuad engine = new QueryEngineRemediatorQuad(query, dataset, binding, context) ;
    return engine.getPlan() ;
}
 

import com.hp.hpl.jena.sparql.engine.Plan; //导入依赖的package包/类
@Override
public Plan create(Query query, DatasetGraph dataset, Binding binding, Context context)
{
    QueryEngineRemediator engine = new QueryEngineRemediator(query, dataset, binding, context) ;
    return engine.getPlan() ;
}