/** * Extracts any {@code SortCondition} instances from the SPARQL query and holds them in an index of their keys * where the value is that keys sorting direction. */ private static Map<String, Order> createOrderIndexFromQuery(final Query query) { final Map<String, Order> orderingIndex = new HashMap<>(); if (query.hasOrderBy()) { final List<SortCondition> sortingConditions = query.getOrderBy(); for (SortCondition sortCondition : sortingConditions) { final Expr expr = sortCondition.getExpression(); // by default, the sort will be ascending. getDirection() returns -2 if the DESC/ASC isn't // supplied - weird orderingIndex.put(expr.getVarName(), sortCondition.getDirection() == -1 ? Order.decr : Order.incr); } } return orderingIndex; }
@Override public int hashCode() { int x = this.getDirection() ; if ( getExpression() != null ) x ^= getExpression().hashCode() ; return x ; }
public static void varsMentioned(Collection<Var> acc, SortCondition sortCondition) { varsMentioned(acc, sortCondition.getExpression()); }
@Override public boolean equals(Object other) { if ( this == other ) return true ; if ( ! ( other instanceof SortCondition ) ) return false ; SortCondition sc = (SortCondition)other ; if ( sc.getDirection() != this.getDirection() ) return false ; if ( ! Objects.equals(this.getExpression(), sc.getExpression()) ) return false ; // if ( ! Utils.eq(this.getVariable(), sc.getVariable()) ) // return false ; return true ; }
/** * Determines whether a sort condition is valid in terms of this optimizer * * @param cond * Sort Condition * @param projectVars * Project Variables * @return True if valid, false otherwise */ private boolean isValidSortCondition(SortCondition cond, List<Var> projectVars) { if (cond.getExpression().isVariable()) { return projectVars.contains(cond.getExpression().asVar()); } else { for (Var v : cond.getExpression().getVarsMentioned()) { if (!projectVars.contains(v)) return false; } return true; } } }
/** * Determines whether a sort condition is valid in terms of this optimizer * * @param cond * Sort Condition * @param projectVars * Project Variables * @return True if valid, false otherwise */ private boolean isValidSortCondition(SortCondition cond, Collection<Var> projectVars, Set<Var> seenVars) { if (cond.getExpression().isVariable()) { if (projectVars.contains(cond.getExpression().asVar())) { seenVars.add(cond.getExpression().asVar()); return true; } return false; } else { for (Var v : cond.getExpression().getVarsMentioned()) { if (!projectVars.contains(v)) return false; seenVars.add(v); } return true; } } }
@Override public void visit(OpOrder op) { for(SortCondition sc :op.getConditions()) { processExpr(sc.getExpression()); } }
protected List<SortCondition> transform(List<SortCondition> conditions) { List<SortCondition> conditions2 = new ArrayList<>() ; boolean changed = false ; for ( SortCondition sc : conditions ) { Expr e = sc.getExpression() ; Expr e2 = transform(e) ; conditions2.add(new SortCondition(e2, sc.getDirection())) ; if ( e != e2 ) changed = true ; } if ( changed ) return conditions2 ; else return conditions ; }
@Override public void visit(OpOrder op) { for(SortCondition sc :op.getConditions()) { processExpr(sc.getExpression()); } }
@Override public void visit(OpOrder opOrder) { mergeVars(opOrder.getSubOp()) ; opOrder.getConditions().forEach(sc-> { sc.getExpression() ; }); }
public static List<SortCondition> transform(NodeTransform nodeTransform, List<SortCondition> conditions) { List<SortCondition> conditions2 = new ArrayList<>() ; boolean same = true ; for ( SortCondition sc : conditions ) { Expr expr = sc.getExpression() ; Expr expr2 = NodeTransformLib.transform(nodeTransform, expr) ; if ( expr != expr2 ) same = false ; SortCondition sc2 = new SortCondition(expr2, sc.getDirection()) ; conditions2.add(sc2) ; } if ( same ) return conditions ; return conditions2 ; }
private List<SortCondition> processConditions(List<SortCondition> baseConditions, List<SortCondition> processedConditions, Var var) { List<SortCondition> inputConditions = processedConditions != null ? processedConditions : baseConditions; List<SortCondition> outputConditions = new ArrayList<>(); for (SortCondition cond : inputConditions) { Expr e = cond.getExpression(); e = ExprTransformer.transform(new ExprTransformSubstitute(var, getAssignExpr(var)), e); outputConditions.add(new SortCondition(e, cond.getDirection())); } return outputConditions; }
/** Find the variables needed out of this query. * If we don't do sorting in-DB, then we need the ORDER BY variables as well. * @param query */ public static List<Var> queryOutVars(Query query) { // If part query, need all variables. // Project variables List<Var> vars = toList(map(query.getResultVars().iterator(), Var::alloc)) ; // Add the ORDER BY variables List<SortCondition> orderConditions = query.getOrderBy() ; if ( orderConditions != null ) { for ( SortCondition sc : orderConditions ) { Set<Var> x = sc.getExpression().getVarsMentioned() ; for ( Var v : x ) { if ( ! vars.contains(v) ) vars.add(v) ; } } } return vars ; }
@Override public void visit(OpOrder op) { op.getSubOp().visit(this); for(SortCondition sc : op.getConditions()) { processExpr(op, sc.getExpression()); } }
public final SortCondition rewrite(SortCondition sortCondition) { sortCondition.getExpression().visit(this); return new SortCondition(pop(), sortCondition.getDirection()); }
@Override public void visit(OpOrder op) { op.getSubOp().visit(this); for(SortCondition sc : op.getConditions()) { processExpr(op, sc.getExpression()); } }
public final SortCondition rewrite(SortCondition sortCondition) { sortCondition.getExpression().visit(this); return new SortCondition(pop(), sortCondition.getDirection()); }
@Override public void visit(OpOrder opOrder) { List<SortCondition> conditions = opOrder.getConditions() ; List<SortCondition> conditions2 = new ArrayList<>() ; boolean changed = false ; for ( SortCondition sc : conditions ) { Expr e = sc.getExpression() ; Expr e2 = transform(e) ; conditions2.add(new SortCondition(e2, sc.getDirection())) ; if ( e != e2 ) changed = true ; } OpOrder x = opOrder ; if ( changed ) x = new OpOrder(opOrder.getSubOp(), conditions2) ; visit1(x) ; }
private void formatSortCondition(SortCondition sc) { boolean close = true ; String tag = null ; if ( sc.getDirection() != Query.ORDER_DEFAULT ) { if ( sc.getDirection() == Query.ORDER_ASCENDING ) { tag = Tags.tagAsc ; WriterLib.start(out, tag, NoNL) ; } if ( sc.getDirection() == Query.ORDER_DESCENDING ) { tag = Tags.tagDesc ; WriterLib.start(out, tag, NoNL) ; } } WriterExpr.output(out, sc.getExpression(), sContext) ; if ( tag != null ) WriterLib.finish(out, tag) ; }
ExprVars.varsMentioned(vars, cond.getExpression());