import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
/**
 * Visits a statement pattern and tries to transform using all rules
 * in the given rule set.
 * 
 * Tries to apply a rule from the rule set. If it is applicable
 * it will recurse using the visitor pattern to the nodes returned
 * from the rule after application.
 * @param node
 * @throws RuntimeException 
 */
@Override
public void meet(StatementPattern node) throws RuntimeException {
	// get a list of rules that may be applicable
	ArrayList<Rule> toApply = new ArrayList<>(getRules(node));
	for (Rule r : toApply) {
		// if a rule can be applied
		if (r.canApply(node)) {
			// apply the rule
			List<QueryModelNode> next = r.apply(node);
			// visit all nodes that the rule returned
			for (QueryModelNode toVisit : next) {
				removeRule(toApply, toVisit, r);
				toVisit.visit(this);
			}
			// halt execution, because the rule transformed the original
			// node and this visit can't transform further. Remaining rules
			// are applied in the recursion (see above).
			break;
		}
	}
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
/**
 * Transform a statement pattern according to OWL-2 subclass axiom.
 *
 * @param node the node to transform
 * @return list of nodes to visit next
 */
@Override
public List<QueryModelNode> apply(StatementPattern node) {
	List<QueryModelNode> next = newNextList();
	StatementPattern left = node.clone();
	// replace the object with the subclass
	StatementPattern right
			= new StatementPattern(
					node.getSubjectVar(),
					node.getPredicateVar(),
					new ConstVar(vf.createURI(ce1)),
					node.getContextVar());
	node.replaceWith(
			new Union(left, right));
	next.add(left);
	next.add(right);
	return next;
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
/**
 * Transform a statement pattern according to OWL-2 subproperty axiom.
 *
 * @param node the node to transform
 * @return list of nodes to visit next
 */
@Override
public List<QueryModelNode> apply(StatementPattern node) {
	List<QueryModelNode> next = newNextList();
	StatementPattern left = node.clone();
	// replace the predicate with the subproperty
	StatementPattern right
			= new StatementPattern(
					node.getSubjectVar(),
					new ConstVar(vf.createURI(op1)),
					node.getObjectVar(),
					node.getContextVar());
	node.replaceWith(
			new Union(left, right));
	next.add(left);
	next.add(right);
	return next;
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
/**
 * Transform a statement pattern according to OWL-2 inverse properties
 * axiom.
 *
 * @param node the node to transform
 * @return list of nodes to visit next
 */
@Override
public List<QueryModelNode> apply(StatementPattern node) {
	List<QueryModelNode> next = newNextList();
	Var s = node.getSubjectVar();
	Var p = node.getPredicateVar();
	Var o = node.getObjectVar();
	Var c = node.getContextVar();
	URI uri = (URI) p.getValue();
	String op = uri.stringValue();
	Var p2;
	// check if need to replace with op1 or op2
	if (op.equals(op1)) {
		p2 = new ConstVar(vf.createURI(op2));
	} else {
		p2 = new ConstVar(vf.createURI(op1));
	}
	StatementPattern left = node.clone();
	// switch subject and object and replace predicate
	StatementPattern right = new StatementPattern(o, p2, s, c);
	node.replaceWith(new Union(left, right));
	next.add(left);
	next.add(right);
	return next;
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
public void meet(StatementPattern node) throws Exception
{
  if (node.getParentNode() instanceof Service && node.getSubjectVar().getName().equals("-const-http://www.bigdata.com/rdf#serviceParam-uri") && node.getPredicateVar().getName().equals("-const-http://wikiba.se/ontology#language-uri")) {
    this.add("LangService");

    // save first asked language
    String value = node.getObjectVar().getValue().stringValue();
    int index = value.indexOf(",");
    if (index != -1) {
      this.primaryLanguage = value.substring(0, index);
    } else {
      this.primaryLanguage = value;
    }
  }
  super.meetNode(node);
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
@Override
protected void meetSP(final StatementPattern node) throws Exception {
    final StatementPattern sp = node.clone();
    final Var predVar = sp.getPredicateVar();

    final URI pred = (URI) predVar.getValue();
    final String predNamespace = pred.getNamespace();

    final Var objVar = sp.getObjectVar();
    final Var cntxtVar = sp.getContextVar();
    if (objVar != null &&
            !RDF.NAMESPACE.equals(predNamespace) &&
            !SESAME.NAMESPACE.equals(predNamespace) &&
            !RDFS.NAMESPACE.equals(predNamespace)
            && !EXPANDED.equals(cntxtVar)) {

        final URI transPropUri = (URI) predVar.getValue();
        if (inferenceEngine.isTransitiveProperty(transPropUri)) {
            node.replaceWith(new TransitivePropertySP(sp.getSubjectVar(), sp.getPredicateVar(), sp.getObjectVar(), sp.getContextVar()));
        }
    }
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
private InferJoin getReplaceJoin(Set<Resource> uris, boolean subSubj, Var subjVar, Var objVar, Var predVar, Var cntxtVar){
    String s = UUID.randomUUID().toString();
    Var dummyVar = new Var(s);
    StatementPattern origStatement;
    Var subVar;
    if (subSubj){
    	subVar = subjVar;
    	origStatement = new DoNotExpandSP(dummyVar, predVar, objVar, cntxtVar);
    }
    else {
    	subVar = objVar;
    	origStatement = new DoNotExpandSP(subjVar, predVar, dummyVar, cntxtVar);
   }
    FixedStatementPattern fsp = new FixedStatementPattern(dummyVar, new Var("c-" + s, OWL.SAMEAS), subVar, cntxtVar);
    for (Resource sameAs : uris){
		NullableStatementImpl newStatement = new NullableStatementImpl(sameAs, OWL.SAMEAS, (Resource)subVar.getValue(), getVarValue(cntxtVar));
        fsp.statements.add(newStatement);        		
	}
    InferJoin join = new InferJoin(fsp, origStatement);
    join.getProperties().put(InferConstants.INFERRED, InferConstants.TRUE);
   return join;
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
private void buildQuery(final TupleExpr tupleExpr, final StatementPattern matchStatement) {
    //If our IndexerExpr (to be) is the rhs-child of LeftJoin, we can safely make that a Join:
    //  the IndexerExpr will (currently) not return results that can deliver unbound variables.
    //This optimization should probably be generalized into a LeftJoin -> Join optimizer under certain conditions. Until that
    //  has been done, this code path at least takes care of queries generated by OpenSahara SparqTool that filter on OPTIONAL
    //  projections. E.g. summary~'full text search' (summary is optional). See #379
    if (matchStatement.getParentNode() instanceof LeftJoin) {
        final LeftJoin leftJoin = (LeftJoin)matchStatement.getParentNode();
        if (leftJoin.getRightArg() == matchStatement && leftJoin.getCondition() == null) {
            matchStatement.getParentNode().replaceWith(new Join(leftJoin.getLeftArg(), leftJoin.getRightArg()));
        }
    }
    final FilterFunction fVisitor = new FilterFunction(matchStatement.getObjectVar().getName());
    tupleExpr.visit(fVisitor);
    final List<IndexingExpr> results = Lists.newArrayList();
    for(int i = 0; i < fVisitor.func.size(); i++){
        results.add(new IndexingExpr(fVisitor.func.get(i), matchStatement, fVisitor.args.get(i)));
    }
    removeMatchedPattern(tupleExpr, matchStatement, new IndexerExprReplacer(results));
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
@Override
public void meet(final StatementPattern node) throws Exception {
    super.meet(node);

    final Var subjectVar = node.getSubjectVar();
    final RangeValue subjRange = rangeValues.get(subjectVar);
    final Var predVar = node.getPredicateVar();
    final RangeValue predRange = rangeValues.get(predVar);
    final Var objVar = node.getObjectVar();
    final RangeValue objRange = rangeValues.get(objVar);
    if(subjRange != null) {
        subjectVar.setValue(new RangeURI(subjRange));//Assumes no blank nodes can be ranges
    }
    if(predRange != null) {
        predVar.setValue(new RangeURI(predRange));
    }
    if(objRange != null) {
        objVar.setValue(objRange);
    }
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
@Override
public void meet(final Filter node) throws Exception {
    super.meet(node);

    final ValueExpr condition = node.getCondition();
    final TupleExpr arg = node.getArg();
    if (!(arg instanceof Join)) {
        return;
    }

    final Join join = (Join) arg;
    final TupleExpr leftArg = join.getLeftArg();
    final TupleExpr rightArg = join.getRightArg();

    if (leftArg instanceof StatementPattern && rightArg instanceof StatementPattern) {
        final Filter left = new Filter(leftArg, condition);
        final Filter right = new Filter(rightArg, condition);
        node.replaceWith(new Join(left, right));
    }

}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
@Override
public double getCardinality(final StatementPattern node) {

    cardinality = super.getCardinality(node);

    // If sp contains all variables or is EmptyRDFtype, assign
    // cardinality
    // equal to table size
    if (cardinality == Double.MAX_VALUE || cardinality == Double.MAX_VALUE - 1) {
        try {
            cardinality = selectEvalStatsDAO.getTableSize(config);
        } catch (final Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    return cardinality;
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
private static List<StatementPattern> getBGP(final QueryModelNode n) {
    if (n instanceof StatementPattern) {
        return Collections.singletonList((StatementPattern) n);
    } else if (!(n instanceof Join)) {
        return null;
    }
    final Join j = (Join) n;
    final List<StatementPattern> l = getBGP(j.getLeftArg());
    final List<StatementPattern> r = getBGP(j.getRightArg());
    if (l == null || r == null) {
        return null;
    }
    if (l.isEmpty()) {
        return r;
    } else if (r.isEmpty()) {
        return l;
    } else if (!equalOrNull(l.get(0).getContextVar(), r.get(0).getContextVar())) {
        return null;
    } else {
        final List<StatementPattern> s = new ArrayList<StatementPattern>(l.size() + r.size());
        s.addAll(l);
        s.addAll(r);
        return s;
    }
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
@Test
public void testReflexiveProperty() throws Exception {
    // Define a reflexive property
    final InferenceEngine inferenceEngine = mock(InferenceEngine.class);
    when(inferenceEngine.isReflexiveProperty(HAS_FAMILY)).thenReturn(true);
    // Construct a query, then visit it
    final StatementPattern sp = new StatementPattern(new Var("s", ALICE), new Var("p", HAS_FAMILY), new Var("o"));
    final Projection query = new Projection(sp, new ProjectionElemList(new ProjectionElem("o", "member")));
    query.visit(new ReflexivePropertyVisitor(conf, inferenceEngine));
    // Expected structure after rewriting SP(:Alice :hasFamilyMember ?member):
    //
    // Union(
    //     originalSP(:Alice :hasFamilyMember ?member),
    //     ZeroLengthPath(:Alice, ?member)
    // )
    Assert.assertTrue(query.getArg() instanceof Union);
    final TupleExpr left = ((Union) query.getArg()).getLeftArg();
    final TupleExpr right = ((Union) query.getArg()).getRightArg();
    Assert.assertEquals(sp, left);
    Assert.assertTrue(right instanceof ZeroLengthPath);
    Assert.assertEquals(sp.getSubjectVar(), ((ZeroLengthPath) right).getSubjectVar());
    Assert.assertEquals(sp.getObjectVar(), ((ZeroLengthPath) right).getObjectVar());
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
@Test
public void testReflexivePropertyDisabled() throws Exception {
    // Disable inference
    final RdfCloudTripleStoreConfiguration disabledConf = conf.clone();
    disabledConf.setInferReflexiveProperty(false);
    // Define a reflexive property
    final InferenceEngine inferenceEngine = mock(InferenceEngine.class);
    when(inferenceEngine.isReflexiveProperty(HAS_FAMILY)).thenReturn(true);
    // Construct a query, then make a copy and visit the copy
    final Projection query = new Projection(
            new StatementPattern(new Var("s", ALICE), new Var("p", HAS_FAMILY), new Var("o")),
            new ProjectionElemList(new ProjectionElem("s", "subject")));
    final Projection modifiedQuery = query.clone();
    modifiedQuery.visit(new ReflexivePropertyVisitor(disabledConf, inferenceEngine));
    // There should be no difference
    Assert.assertEquals(query, modifiedQuery);
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
@Test
public void testSomeValuesFromDisabled() throws Exception {
    // Disable someValuesOf inference
    final AccumuloRdfConfiguration disabledConf = conf.clone();
    disabledConf.setInferSomeValuesFrom(false);
    // Configure a mock instance engine with an ontology:
    final InferenceEngine inferenceEngine = mock(InferenceEngine.class);
    Map<Resource, Set<URI>> personSVF = new HashMap<>();
    personSVF.put(gradCourse, Sets.newHashSet(takesCourse));
    personSVF.put(course, Sets.newHashSet(takesCourse));
    personSVF.put(department, Sets.newHashSet(headOf));
    personSVF.put(organization, Sets.newHashSet(worksFor, headOf));
    when(inferenceEngine.getSomeValuesFromByRestrictionType(person)).thenReturn(personSVF);
    // Query for a specific type visit -- should not change
    StatementPattern originalSP = new StatementPattern(new Var("s"), new Var("p", RDF.TYPE), new Var("o", person));
    final Projection originalQuery = new Projection(originalSP, new ProjectionElemList(new ProjectionElem("s", "subject")));
    final Projection modifiedQuery = originalQuery.clone();
    modifiedQuery.visit(new SomeValuesFromVisitor(disabledConf, inferenceEngine));
    Assert.assertEquals(originalQuery, modifiedQuery);
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
public Set<Set<TupleExpr>> groupEquivalentPlans(Collection<TupleExpr> plans) {
	
	// put query plans in same category if the have the same patterns
	Map<Set<StatementPattern>, Set<TupleExpr>> equivalent = new HashMap<Set<StatementPattern>, Set<TupleExpr>>();

	// Collect all equivalent plans, i.e. plans with the same patterns
	for (TupleExpr plan : plans) {
		Set<StatementPattern> patterns = new HashSet<StatementPattern>(StatementPatternCollector.process(plan));
		Set<TupleExpr> planSet = equivalent.get(patterns);
		
		if (planSet == null) {
			planSet = new HashSet<TupleExpr>();
			equivalent.put(patterns, planSet);
		}
		
		planSet.add(plan);
	}
	return new HashSet<Set<TupleExpr>>(equivalent.values());
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
@Test(expected = IllegalStateException.class)
public void constructor_variablePredicate() throws Exception {
    // A pattern that has a variable for its predicate.
    final Var geoSubj = new Var("point");
    final Var geoPred = new Var("geo");
    final Var geoObj = new Var("wkt");
    final StatementPattern geoSP = new StatementPattern(geoSubj, geoPred, geoObj);

    final Var timeSubj = new Var("time");
    final Var timePred = new Var("-const-http://www.w3.org/2006/time#inXSDDateTime", ValueFactoryImpl.getInstance().createURI("-const-http://www.w3.org/2006/time#inXSDDateTime"));
    final Var timeObj = new Var("time");
    final StatementPattern timeSP = new StatementPattern(timeSubj, timePred, timeObj);
    // This will fail.
    new EventQueryNode.EventQueryNodeBuilder()
    .setStorage(mock(EventStorage.class))
    .setGeoPattern(geoSP)
    .setTemporalPattern(timeSP)
    .setGeoFilters(new ArrayList<IndexingExpr>())
    .setTemporalFilters(new ArrayList<IndexingExpr>())
    .setUsedFilters(new ArrayList<>())
    .build();
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
@Override
public void meet(Join node) {
    try {
        if (node.getLeftArg() instanceof FixedStatementPattern && node.getRightArg() instanceof DoNotExpandSP) {
            return;
        }
        List<TupleExpr> joinArgs = getJoinArgs(node, new ArrayList<TupleExpr>());
        HashMultimap<String, StatementPattern> varMap = getVarBins(joinArgs);
        while (!varMap.keySet().isEmpty()) {
            String s = getHighestPriorityKey(varMap);
            constructTuple(varMap, joinArgs, s);
        }
        List<TupleExpr> filterChain = getFilterChain(joinArgs);

        for (TupleExpr te : joinArgs) {
            if (!(te instanceof StatementPattern) || !(te instanceof EntityTupleSet)) {
                te.visit(this);
            }
        }
        // Replace old join hierarchy
        node.replaceWith(getNewJoin(joinArgs, filterChain));

    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
@Test
public void testProjection() throws Exception {
    StatementPattern isUndergrad = new StatementPattern(new Var("x"), constant(RDF.TYPE), constant(UNDERGRAD));
    StatementPattern isCourse = new StatementPattern(new Var("course"), constant(RDF.TYPE), constant(COURSE));
    StatementPattern hasEdge = new StatementPattern(new Var("x"), new Var("p"), new Var("course"));
    ProjectionElemList projectionElements = new ProjectionElemList(
            new ProjectionElem("p", "relation"),
            new ProjectionElem("course"));
    QueryRoot queryTree = new QueryRoot(new Projection(
            new Join(new Join(isCourse, hasEdge), isUndergrad),
            projectionElements));
    SparqlToPipelineTransformVisitor visitor = new SparqlToPipelineTransformVisitor(collection);
    queryTree.visit(visitor);
    Assert.assertTrue(queryTree.getArg() instanceof AggregationPipelineQueryNode);
    AggregationPipelineQueryNode pipelineNode = (AggregationPipelineQueryNode) queryTree.getArg();
    Assert.assertEquals(Sets.newHashSet("relation", "course"), pipelineNode.getAssuredBindingNames());
}
 

import org.openrdf.query.algebra.StatementPattern; //导入依赖的package包/类
@Test
public void testMultiProjection() throws Exception {
    StatementPattern isUndergrad = new StatementPattern(new Var("x"), constant(RDF.TYPE), constant(UNDERGRAD));
    StatementPattern isCourse = new StatementPattern(new Var("course"), constant(RDF.TYPE), constant(COURSE));
    StatementPattern hasEdge = new StatementPattern(new Var("x"), new Var("p"), new Var("course"));
    ProjectionElemList courseHasRelation = new ProjectionElemList(
            new ProjectionElem("p", "relation"),
            new ProjectionElem("course"));
    ProjectionElemList studentHasRelation = new ProjectionElemList(
            new ProjectionElem("p", "relation"),
            new ProjectionElem("x", "student"));
    QueryRoot queryTree = new QueryRoot(new MultiProjection(
            new Join(new Join(isCourse, hasEdge), isUndergrad),
            Arrays.asList(courseHasRelation, studentHasRelation)));
    SparqlToPipelineTransformVisitor visitor = new SparqlToPipelineTransformVisitor(collection);
    queryTree.visit(visitor);
    Assert.assertTrue(queryTree.getArg() instanceof AggregationPipelineQueryNode);
    AggregationPipelineQueryNode pipelineNode = (AggregationPipelineQueryNode) queryTree.getArg();
    Assert.assertEquals(Sets.newHashSet("relation"), pipelineNode.getAssuredBindingNames());
    Assert.assertEquals(Sets.newHashSet("relation", "course", "student"), pipelineNode.getBindingNames());
}