/** * Visiting filters in SPARQL algebra. */ @Override public void visit(final OpFilter opFilter) { Traversal traversal; for (Expr expr : opFilter.getExprs().getList()) { if (expr != null) { traversal = __.where(WhereTraversalBuilder.transform(expr)); traversalList.add(traversal); } } }
/** * Visiting LeftJoin(Optional) in SPARQL algebra. */ @Override public void visit(final OpLeftJoin opLeftJoin) { optionalFlag = true; optionalVisit(opLeftJoin.getRight()); if (opLeftJoin.getExprs() != null) { for (Expr expr : opLeftJoin.getExprs().getList()) { if (expr != null) { if (optionalFlag) optionalTraversals.add(__.where(WhereTraversalBuilder.transform(expr))); } } } }
@Override public List<Expr> getArgs() { return args.getList() ; }
public void addAll(ExprList exprs) { expressions.addAll(exprs.getList()) ; } public void add(Expr expr) { expressions.add(expr) ; }
public static Set<Set<Expr>> toSets(List<ExprList> clauses) { if(clauses == null) { return null; } Set<Set<Expr>> result = new HashSet<Set<Expr>>(); for(ExprList clause : clauses) { result.add(new HashSet<Expr>(clause.getList())); } return result; }
/** Prescan to see if anything to consider */ private static boolean interesting(ExprList exprList) { return exprList.getList().stream().anyMatch((e) -> processable(e)); }
@Override public void visit(final OpFilter opFilter) { opFilter.getExprs().getList().stream(). map(WhereTraversalBuilder::transform). reduce(traversal, GraphTraversal::where); } }
public static Collection<ProblemNeighborhoodAware<Map<Var, Var>, Var>> deriveProblemsFilter(OpFilter cacheOp, OpFilter userOp) { ProblemNeighborhoodAware<Map<Var, Var>, Var> tmp = new ProblemVarMappingExpr(cacheOp.getExprs().getList(), userOp.getExprs().getList(), Collections.emptyMap()); Collection<ProblemNeighborhoodAware<Map<Var, Var>, Var>> result = Collections.singleton(tmp); return result; }
@Override public void visit(OpFilter opFilter) { Collection<Var> vars = new ArrayList<>(); for (Expr expr : opFilter.getExprs().getList()) { ExprVars.varsMentioned(vars, expr); } action(vars); }
protected E_Call(String sym, ExprList args) { super(sym, args) ; if (args.size() == 0) { identExpr = null; } else { identExpr = args.get(0); argExprs = args.getList().subList(1,args.size()) ; } }
private static Pair<List<Pair<Var, NodeValue>>, ExprList> preprocessFilterInequality(ExprList exprs) { List<Pair<Var, NodeValue>> exprsFilterInequality = new ArrayList<>(); ExprList exprsOther = new ExprList(); for (Expr e : exprs.getList()) { Pair<Var, NodeValue> p = preprocess(e); if (p != null) exprsFilterInequality.add(p); else exprsOther.add(e); } if (exprsFilterInequality.size() == 0) return null; return Pair.create(exprsFilterInequality, exprsOther); }
private static Pair<List<Pair<Var, NodeValue>>, ExprList> preprocessFilterEquality(ExprList exprs) { List<Pair<Var, NodeValue>> exprsFilterEquality = new ArrayList<>(); ExprList exprsOther = new ExprList(); for (Expr e : exprs.getList()) { Pair<Var, NodeValue> p = preprocess(e); if (p != null) exprsFilterEquality.add(p); else exprsOther.add(e); } if (exprsFilterEquality.size() == 0) return null; return Pair.create(exprsFilterEquality, exprsOther); }
private static Pair<List<Pair<Var, Var>>, ExprList> preprocessFilterImplicitJoin(Op subOp, ExprList exprs) { List<Pair<Var, Var>> exprsJoins = new ArrayList<>(); ExprList exprsOther = new ExprList(); for (Expr e : exprs.getList()) { Pair<Var, Var> p = preprocess(subOp, e); if (p != null) { exprsJoins.add(p); } else { exprsOther.add(e); } } if (exprsJoins.size() == 0) return null; return Pair.create(exprsJoins, exprsOther); }
public Expr copy(Expr proto, List<Expr> args) { Expr result; if(!proto.isFunction()) { throw new RuntimeException("Must not be called on non-functions"); } ExprFunction fn = proto.getFunction(); result = copy(fn, args); return result; }
@Override public void visit(OpLeftJoin opLeftJoin) { Collection<Var> vars = new ArrayList<>(); if (opLeftJoin.getExprs() != null) { for (Expr expr : opLeftJoin.getExprs().getList()) { ExprVars.varsMentioned(vars, expr); } } action(vars); }
private Expr xform(ExprFunctionN func, ExprList args) { if ( !alwaysCopy && equals1(func.getArgs(), args.getList()) ) return func ; return func.copy(args) ; }
@Override public Expr transform(ExprFunctionN func, ExprList args) { Expr result = isConcatFunction.test(func) ? func.copy(new ExprList(mergeConsecutiveConstants(args.getList()))) : super.transform(func, args); return result; }
@Override public Expr transform(ExprFunctionN func, ExprList args) { Expr result = isConcatFunction.test(func) ? func.copy(new ExprList(mergeConsecutiveConstants(args.getList()))) : super.transform(func, args); return result; }
/** * * @param expr * @return */ public static List<Expr> getOptimizedConcatArgs(Expr expr) { List<Expr> args = isConcatExpr(expr) ? expr.getFunction().getArgs() : Collections.singletonList(expr); List<Expr> result = mergeConsecutiveConstants(args).getList(); return result; }
private Expr xform(ExprFunctionOp funcOp, ExprList args, Op opArg) { if ( !alwaysCopy && equals1(funcOp.getArgs(), args.getList()) && funcOp.getGraphPattern() == opArg ) return funcOp ; return funcOp.copy(args, opArg) ; }