public static Set<Var> allVars(Op op) { Set<Var> acc = new HashSet<Var>() ; allVars(op, acc) ; return acc ; }
public static Collection<Var> mentionedVars(Op op) { Set<Var> acc = collector() ; mentionedVars(op, acc) ; return acc ; }
public static Set<Var> visibleVars(Op op) { Set<Var> acc = collector() ; visibleVars(op, acc) ; return acc ; }
/** @deprecated use {@linkplain #visibleVars} */ @Deprecated public static Set<Var> patternVars(Op op) { return visibleVars(op) ; }
@Override public void visit(OpBGP opBGP) { vars(opBGP.getPattern(), acc) ; }
public static Set<Var> patternVars(Op op) { Set<Var> acc = new HashSet<Var>() ; patternVars(op, acc) ; return acc ; }
private static Pair<Var, Var> preprocess(Op opLeft, Op opRight, Expr e) { if (!(e instanceof E_Equals) && !(e instanceof E_SameTerm)) return null; ExprFunction2 eq = (ExprFunction2) e; // An equals or same term implicit join Expr left = eq.getArg1(); Expr right = eq.getArg2(); if (!left.isVariable() || !right.isVariable()) { return null; } if (left.equals(right)) { return null; } // If neither variable is visible in RHS optimization does not apply Collection<Var> rhsVars = OpVars.visibleVars(opRight); if (!rhsVars.contains(left.asVar()) && !rhsVars.contains(right.asVar())) return null; if (e instanceof E_Equals) { // Is a safe equals for this optimization? Tuple<Set<Var>> varsByPosition = OpVars.mentionedVarsByPosition(opLeft, opRight); if (!isSafeEquals(varsByPosition, left.asVar(), right.asVar())) return null; } return Pair.create(left.asVar(), right.asVar()); }
@SuppressWarnings("unchecked") public static Tuple<Set<Var>> mentionedVarsByPosition(Op... ops) { Set<Var> graphAcc = collector() ; Set<Var> subjAcc = collector() ; Set<Var> predAcc = collector() ; Set<Var> objAcc = collector() ; Set<Var> unknownAcc = collector() ; OpVarsPatternWithPositions visitor = new OpVarsPatternWithPositions(graphAcc, subjAcc, predAcc, objAcc, unknownAcc, false); for (Op op : ops) OpWalker.walk(op, visitor); return Tuple.createTuple(graphAcc, subjAcc, predAcc, objAcc, unknownAcc); }
private Set<Var> fixedVars(Op op) { return OpVars.fixedVars(op) ; }
@Override public void visit(OpProcedure opProc) { unknownAcc.addAll(OpVars.mentionedVars(opProc)); }
public static void vars(BasicPattern pattern, Collection<Var> acc) { for ( Triple triple : pattern ) addVarsFromTriple(acc, triple) ; }
private static Pair<Var, Var> preprocess(Op subOp, Expr e) { // TODO Should also handle the case of && as TransformImplicitLeftJoin // is already capable of doing if (!(e instanceof E_Equals) && !(e instanceof E_SameTerm)) return null; ExprFunction2 eq = (ExprFunction2) e; Expr left = eq.getArg1(); Expr right = eq.getArg2(); if (!left.isVariable() || !right.isVariable()) { return null; } if (left.equals(right)) { return null; } if (e instanceof E_Equals) { // Is a safe equals for this optimization? Tuple<Set<Var>> varsByPosition = OpVars.mentionedVarsByPosition(subOp); if (!isSafeEquals(varsByPosition, left.asVar(), right.asVar())) return null; } return Pair.create(left.asVar(), right.asVar()); }
private static boolean testSpecialCaseUnused(Op op, List<Pair<Var, NodeValue>> equalities, ExprList remaining) { // If the op does not contain the var at all, for some equality // then the filter expression will be "eval unbound" i.e. false. // We can return empty table. Set<Var> patternVars = OpVars.visibleVars(op); for (Pair<Var, NodeValue> p : equalities) { if (!patternVars.contains(p.getLeft())) return true; } return false; }
@Override public void visit(OpQuadPattern quadPattern) { addVar(acc, quadPattern.getGraphNode()) ; vars(quadPattern.getBasicPattern(), acc) ; // Pure quading // for ( Iterator iter = quadPattern.getQuads().iterator() ; iter.hasNext() ; ) // { // Quad quad = (Quad)iter.next() ; // addVarsFromQuad(acc, quad) ; // } }
static public Set<Var> nonLinearVars(OpLeftJoin op) { Op left = JoinClassifier.effectiveOp(op.getLeft()) ; Op right = JoinClassifier.effectiveOp(op.getRight()) ; Set<Var> leftVars = OpVars.patternVars(left) ; Set<Var> optRight = VarFinder.optDefined(right) ; return SetUtils.intersection(leftVars, optRight) ; } }
@SuppressWarnings("unchecked") public static Tuple<Set<Var>> mentionedVarsByPosition(Op op) { Set<Var> graphAcc = collector() ; Set<Var> subjAcc = collector() ; Set<Var> predAcc = collector() ; Set<Var> objAcc = collector() ; Set<Var> unknownAcc = collector() ; OpVarsPatternWithPositions visitor = new OpVarsPatternWithPositions(graphAcc, subjAcc, predAcc, objAcc, unknownAcc, false); OpWalker.walk(op, visitor); return Tuple.createTuple(graphAcc, subjAcc, predAcc, objAcc, unknownAcc); }