/** transform an expression that may involve aggregates into one that just uses the variable for the aggregate */ public static Expr replaceAggregateByVariable(Expr expr) { return ExprTransformer.transform(replaceAgg, expr) ; }
private static Expr transform(Expr expr, ExprTransform exprTransform) { if ( expr == null || exprTransform == null ) return expr ; return ExprTransformer.transform(exprTransform, expr) ; }
/** transform expressions that may involve aggregates into one that just uses the variable for the aggregate */ public static ExprList replaceAggregateByVariable(ExprList exprs) { return ExprTransformer.transform(replaceAgg, exprs) ; }
private static ExprList transform(ExprList exprList, ExprTransform exprTransform) { if ( exprList == null || exprTransform == null ) return exprList ; return ExprTransformer.transform(exprTransform, exprList) ; }
/** transform expressions that may involve aggregates into one that just uses the variable for the aggregate */ public static ExprList replaceAggregateByVariable(ExprList exprs) { return ExprTransformer.transform(replaceAgg, exprs) ; }
/** transform an expression that may involve aggregates into one that just uses the variable for the aggregate */ public static Expr replaceAggregateByVariable(Expr expr) { return ExprTransformer.transform(replaceAgg, expr) ; }
/** * Adds a function * * @param uri * URI * @param e * Expression * @param args * Arguments */ public void add(String uri, Expr e, List<Var> args) { if (!preserveDependencies) { // If not allowing dependencies expand expression fully e = ExprTransformer.transform(new ExprTransformExpand(this.definitions), e); } UserDefinedFunctionDefinition def = new UserDefinedFunctionDefinition(uri, e, args); this.definitions.put(uri, def); FunctionRegistry.get().put(uri, this); }
/** * Builds the expression substituting the arguments given into the base expression to yield the actual expression to evaluate * @throws ExprBuildException Thrown if an expression cannot be generated */ @Override public void build(String uri, ExprList args) { //Substitutes the arguments into the base expression to give the actual expression to evaluate if (uri == null || !uri.equals(this.getUri())) throw new ExprBuildException("Incorrect URI passed to build() call, expected <" + this.getUri() + "> but got <" + uri + ">"); if (this.getArgList().size() != args.size()) throw new ExprBuildException("Incorrect number of arguments for user defined <" + this.getUri() + "> function"); Map<String, Expr> substitutions = new HashMap<String, Expr>(); for (int i = 0; i < this.getArgList().size(); i++) { substitutions.put(this.getArgList().get(i).getVarName(), args.get(i)); } this.actualExpr = ExprTransformer.transform(new ExprTransformSubstitute(substitutions), this.getBaseExpr()); }
/** * Adds a function * <p> * This method will build the expression to use based on the expression * string given, strings must match the SPARQL expression syntax e.g. * </p> * * <pre> * (?x * ?y) + 5 * </pre> * * @param uri * URI * @param expr * Expression String (in SPARQL syntax) * @param args * Arguments * @throws ParseException * Thrown if the expression string is not valid syntax */ public void add(String uri, String expr, List<Var> args) throws ParseException { Expr e = new SPARQLParser11(new StringReader(expr)).Expression(); if (!preserveDependencies) { // If not allowing dependencies expand expression fully e = ExprTransformer.transform(new ExprTransformExpand(this.definitions), e); } UserDefinedFunctionDefinition def = new UserDefinedFunctionDefinition(uri, e, args); this.definitions.put(uri, def); FunctionRegistry.get().put(uri, this); }
@Override public void visit(OpOrder opOrder) { List<SortCondition> conditions = opOrder.getConditions() ; List<SortCondition> conditions2 = new ArrayList<SortCondition>() ; boolean changed = false ; for ( SortCondition sc : conditions ) { Expr e = sc.getExpression() ; Expr e2 = ExprTransformer.transform(exprTransform, 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) ; }
@Override public Op transform(OpFilter opFilter, Op x) { ExprList ex = new ExprList() ; for ( Expr e : opFilter.getExprs() ) { Expr e2 = ExprTransformer.transform(exprTransform, e) ; ex.add(e2) ; } OpFilter f = (OpFilter)OpFilter.filter(ex, x) ; return super.transform(f, x) ; } }
private VarExprList process(VarExprList varExpr) { List<Var> vars = varExpr.getVars() ; VarExprList varExpr2 = new VarExprList() ; boolean changed = false ; for ( Var v : vars ) { Expr e = varExpr.getExpr(v) ; Expr e2 = e ; if ( e != null ) e2 = ExprTransformer.transform(exprTransform, e) ; if ( e2 == null ) varExpr2.add(v) ; else varExpr2.add(v, e2) ; if ( e != e2 ) changed = true ; } if ( ! changed ) return varExpr ; return varExpr2 ; }
@Override public void visit(OpFilter opFilter) { ExprList ex = new ExprList() ; boolean changed = false ; for ( Expr e : opFilter.getExprs() ) { Expr e2 = ExprTransformer.transform(exprTransform, e) ; ex.add(e2) ; if ( e != e2 ) changed = true ; } OpFilter f = opFilter ; if ( changed ) f = (OpFilter)OpFilter.filter(ex, opFilter.getSubOp()) ; visit1(f) ; }
ExprList exprList = ExprTransformer.transform(transformer, el);
/** * {@inheritDoc} */ @Override public final boolean validatesKeyConstraints(Zone<SemanticElement> zone) { this.transformer = new FilterTransformer(zone, this.atomicQuery); // check fixed parts for (byte i = 0; i < super.key.getValue().size(); i++) { // if coordinate is null we skip the test if (super.key.getValue().getElement(i) != null) { // the specified overlay does not contains the key if (zone.contains(i, super.key.getValue().getElement(i)) != 0) { return false; } } } if (this.atomicQuery.getFilterConstraints().size() > 0) { for (int i = 0; i < this.atomicQuery.getFilterConstraints().size(); i++) { ExprTransformer.transform( this.getTransformer(), this.atomicQuery.getFilterConstraints().get(i)); } return this.getTransformer().finalDecision; } else { // no filter condition to apply on this atomic query return true; } }
Expr tr = ExprTransformer.transform(sefr, e);
Expr tr = ExprTransformer.transform(new SubExprForVar(varExpression), e);