import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
static CloseableIteration<BindingSet, QueryEvaluationException> evaluate(
        final TripleTransaction transaction, final TupleExpr expr,
        @Nullable final Dataset dataset, @Nullable final BindingSet bindings,
        @Nullable final Long timeout) throws QueryEvaluationException {

    Preconditions.checkNotNull(transaction);

    final AtomicBoolean delegate = new AtomicBoolean(false);
    expr.visit(new QueryModelVisitorBase<RuntimeException>() {

        @Override
        public void meet(final StatementPattern node) throws RuntimeException {
            delegate.set(true);
        }

    });

    final EvaluationStrategy strategy = delegate.get() ? new DelegatingEvaluationStrategy(
            transaction, dataset, timeout, false) : new LocalEvaluationStrategy(transaction,
            dataset, timeout);

    return strategy
            .evaluate(expr, bindings != null ? bindings : EmptyBindingSet.getInstance());
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
@Override
protected CloseableIteration<BindingSet, QueryEvaluationException> evaluateInternal(
    TupleExpr expr, Dataset dataset, BindingSet bindings, boolean includeInferred)
    throws SailException {
  triples.flush();
  try {
    TupleExpr tupleExpr;
    EvaluationStrategy strategy;
    strategy = factory.createRdbmsEvaluation(dataset);
    tupleExpr = optimizer.optimize(expr, dataset, bindings, strategy);
    // Mexri edw to GeneralDBSqlDiffDateTime ftanei kanonika
    return strategy.evaluate(tupleExpr, EmptyBindingSet.getInstance());
  } catch (QueryEvaluationException e) {
    throw new SailException(e);
  }
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
@Override
public CloseableIteration<? extends BindingSet, QueryEvaluationException> evaluate(
		TupleExpr tupleExpr, Dataset dataset, BindingSet bindings,
		boolean includeInferred) throws SailException {
	try {
		
		IdentifiersOrgTripleSource tripleSource = new IdentifiersOrgTripleSource(vf, dao);
		EvaluationStrategy strategy = new EvaluationStrategyImpl(tripleSource);
		tupleExpr = tupleExpr.clone();
		new BindingAssigner().optimize(tupleExpr, dataset, bindings);

		new FilterOptimizer().optimize(tupleExpr, dataset, bindings);
		return strategy.evaluate(tupleExpr, EmptyBindingSet.getInstance());
	} catch (QueryEvaluationException e) {
		throw new SailException(e);
	}
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
public ParallelJoinIterator(EvaluationStrategy strategy, Join join, BindingSet bindings, ExecutorService executorService, int batch)
        throws QueryEvaluationException {
    this.strategy = strategy;
    this.join = join;
    leftIter = strategy.evaluate(join.getLeftArg(), bindings);

    this.executorService = executorService;
    this.batch = batch;
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
/**
 * Return whether a concrete statement satisfies a condition.
 * @param stmt A statement from the input
 * @param condition The condition to test. Expects variables expressed using the standard variable
 * names used by this class, so it must be a rule's condition or derived from rules' conditions.
 * @param strategy The evaluation strategy to apply
 * @return True if the statement matches the condition
 * @throws ValueExprEvaluationException
 * @throws QueryEvaluationException
 */
public static boolean accept(final Statement stmt, final ValueExpr condition, final EvaluationStrategy strategy)
        throws ValueExprEvaluationException, QueryEvaluationException {
    final QueryBindingSet bindings = new QueryBindingSet();
    bindings.addBinding(SUBJ_VAR.getName(), stmt.getSubject());
    bindings.addBinding(PRED_VAR.getName(), stmt.getPredicate());
    bindings.addBinding(OBJ_VAR.getName(), stmt.getObject());
    if (stmt.getContext() != null) {
        bindings.addBinding(CON_VAR.getName(), stmt.getContext());
    }
    return strategy.isTrue(condition, bindings);
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
public StSPARQLFilterIterator(Filter filter,
    CloseableIteration<BindingSet, QueryEvaluationException> iter, Set<String> spatialConstructs,
    EvaluationStrategy strategy) throws QueryEvaluationException {
  super(iter);
  this.filter = filter;
  this.strategy = strategy;
  this.scopeBindingNames = filter.getBindingNames();
  this.scopeBindingNames.addAll(spatialConstructs);
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
public StSPARQLGroupIterator(EvaluationStrategy strategy, Group group, BindingSet parentBindings)
    throws QueryEvaluationException {
  this.strategy = strategy;
  this.group = group;
  this.parentBindings = parentBindings;
  super.setIterator(createIterator());
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
private void coreOptimizations(EvaluationStrategy strategy, TupleExpr expr, Dataset dataset,
    BindingSet bindings) {
  new BindingAssigner().optimize(expr, dataset, bindings);
  // addition
  new stSPARQLConstantOptimizer(strategy).optimize(expr, dataset, bindings);
  //
  new CompareOptimizer().optimize(expr, dataset, bindings);
  new ConjunctiveConstraintSplitter().optimize(expr, dataset, bindings);
  new DisjunctiveConstraintOptimizer().optimize(expr, dataset, bindings);
  new SameTermFilterOptimizer().optimize(expr, dataset, bindings);

  // XXX
  new SpatialJoinOptimizer().optimize(expr, dataset, bindings, spatialJoins);
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
@Override
public CloseableIteration<? extends BindingSet, QueryEvaluationException> evaluate(
		TupleExpr tupleExpr, Dataset dataset, BindingSet bindings,
		boolean includeInferred) throws SailException {
	try {
		BEDTripleSource tripleSource = new BEDTripleSource(file, vf);
		EvaluationStrategy strategy = new OneLineAwareEvaluationStrategy(
				tripleSource);
		tupleExpr = tupleExpr.clone();
		new BindingAssigner().optimize(tupleExpr, dataset, bindings);
		new ConstantOptimizer(strategy).optimize(tupleExpr, dataset,
				bindings);
		new CompareOptimizer().optimize(tupleExpr, dataset, bindings);
		new ConjunctiveConstraintSplitter().optimize(tupleExpr, dataset,
				bindings);
		new DisjunctiveConstraintOptimizer().optimize(tupleExpr, dataset,
				bindings);
		new SameTermFilterOptimizer()
				.optimize(tupleExpr, dataset, bindings);
		new QueryModelNormalizer().optimize(tupleExpr, dataset, bindings);

		// new SubSelectJoinOptimizer().optimize(tupleExpr, dataset,
		// bindings);
		new IterativeEvaluationOptimizer().optimize(tupleExpr, dataset,
				bindings);
		new FilterOptimizer().optimize(tupleExpr, dataset, bindings);
		new OrderLimitOptimizer().optimize(tupleExpr, dataset, bindings);

		return strategy.evaluate(tupleExpr, EmptyBindingSet.getInstance());
	} catch (QueryEvaluationException e) {
		throw new SailException(e);
	}
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
public EvaluationStrategy getEvalStrategy() {
	return this.evalStrategy;
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
public TrueCardinalityEstimator(EvaluationStrategy evalStrategy) {
	this.evalStrategy = evalStrategy;
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
public void setEvalStrategy(EvaluationStrategy evalStrategy) {
//		if (evalStrategy == null)
//			throw new IllegalArgumentException("evaluation strategy must not be NULL");
		this.evalStrategy = evalStrategy;
	}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
public StSPARQLOrderComparator(EvaluationStrategy strategy, Order order, Comparator vcmp) {
  this.strategy = strategy;
  this.order = order;
  this.cmp = vcmp;
}
 

import org.openrdf.query.algebra.evaluation.EvaluationStrategy; //导入依赖的package包/类
public stSPARQLConstantOptimizer(EvaluationStrategy strategy) {
  this.strategy = strategy;
}