private static ILogicalExpression vre(LogicalVariable var) { if (var == null) { throw new NullPointerException(); } return new VariableReferenceExpression(var); }
@Override public AbstractLogicalExpression cloneExpression() { VariableReferenceExpression varRef = new VariableReferenceExpression(variable); varRef.setSourceLocation(sourceLoc); return varRef; }
private static ILogicalExpression createFunctionCall(Function fn, List<LogicalVariable> vars) { List<Mutable<ILogicalExpression>> args = new ArrayList<Mutable<ILogicalExpression>>(); for (LogicalVariable var : vars) { args.add(mutable(new VariableReferenceExpression(var))); } return new ScalarFunctionCallExpression(fn, args); }
private AggregateOperator getAggregateOperator(LogicalVariable unnestVariable, LogicalVariable aggregateVariable) { List<LogicalVariable> aggregateVariables = new ArrayList<LogicalVariable>(); aggregateVariables.add(aggregateVariable); List<Mutable<ILogicalExpression>> aggregateSequenceArgs = new ArrayList<Mutable<ILogicalExpression>>(); Mutable<ILogicalExpression> unnestVariableRef = new MutableObject<ILogicalExpression>( new VariableReferenceExpression(unnestVariable)); aggregateSequenceArgs.add(unnestVariableRef); List<Mutable<ILogicalExpression>> exprs = new ArrayList<Mutable<ILogicalExpression>>(); ILogicalExpression aggregateExp = new AggregateFunctionCallExpression(BuiltinOperators.SEQUENCE, false, aggregateSequenceArgs); Mutable<ILogicalExpression> aggregateExpRef = new MutableObject<ILogicalExpression>(aggregateExp); exprs.add(aggregateExpRef); return new AggregateOperator(aggregateVariables, exprs); }
private AssignOperator getAssignOperator(LogicalVariable unnestVariable, LogicalVariable outputVariable, IFunctionInfo inputFunction) { List<Mutable<ILogicalExpression>> nodeArgs = new ArrayList<Mutable<ILogicalExpression>>(); nodeArgs.add(new MutableObject<ILogicalExpression>(new VariableReferenceExpression(unnestVariable))); ScalarFunctionCallExpression unctionExpression = new ScalarFunctionCallExpression(inputFunction, nodeArgs); Mutable<ILogicalExpression> nodeTreeIdExpression = new MutableObject<ILogicalExpression>(unctionExpression); return new AssignOperator(outputVariable, nodeTreeIdExpression); }
public VariableReferenceExpression getVariableReferenceExpression(Identifier id) throws CompilationException { LogicalVariable var = map.get(id); if (var == null) { throw new CompilationException(ErrorCode.COMPILATION_AQLPLUS_IDENTIFIER_NOT_FOUND, id.toString()); } return new VariableReferenceExpression(var); }
private UnnestOperator getUnnestOperator(LogicalVariable inputVariable, LogicalVariable unnestVariable) { VariableReferenceExpression inputVre = new VariableReferenceExpression(inputVariable); List<Mutable<ILogicalExpression>> iterateArgs = new ArrayList<Mutable<ILogicalExpression>>(); iterateArgs.add(new MutableObject<ILogicalExpression>(inputVre)); ILogicalExpression unnestExp = new UnnestingFunctionCallExpression(BuiltinOperators.ITERATE, iterateArgs); Mutable<ILogicalExpression> unnestExpRef = new MutableObject<ILogicalExpression>(unnestExp); return new UnnestOperator(unnestVariable, unnestExpRef); }
private UnnestOperator getUnnestOperator(LogicalVariable inputVariable, LogicalVariable unnestVariable) { VariableReferenceExpression inputVre = new VariableReferenceExpression(inputVariable); List<Mutable<ILogicalExpression>> iterateArgs = new ArrayList<Mutable<ILogicalExpression>>(); iterateArgs.add(new MutableObject<ILogicalExpression>(inputVre)); ILogicalExpression unnestExp = new UnnestingFunctionCallExpression(BuiltinOperators.ITERATE, iterateArgs); Mutable<ILogicalExpression> unnestExpRef = new MutableObject<ILogicalExpression>(unnestExp); return new UnnestOperator(unnestVariable, unnestExpRef); }
private static AbstractFunctionCallExpression createPointExpression(List<LogicalVariable> pointVars, SourceLocation sourceLoc) { List<Mutable<ILogicalExpression>> expressions = new ArrayList<>(); AbstractFunctionCallExpression createPointExpr1 = new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.CREATE_POINT)); createPointExpr1.setSourceLocation(sourceLoc); VariableReferenceExpression pointVarRef0 = new VariableReferenceExpression(pointVars.get(0)); pointVarRef0.setSourceLocation(sourceLoc); expressions.add(new MutableObject<ILogicalExpression>(pointVarRef0)); VariableReferenceExpression pointVarRef1 = new VariableReferenceExpression(pointVars.get(1)); pointVarRef1.setSourceLocation(sourceLoc); expressions.add(new MutableObject<ILogicalExpression>(pointVarRef1)); createPointExpr1.getArguments().addAll(expressions); return createPointExpr1; }
public static void prepareVarAndExpression(List<String> field, LogicalVariable resVar, List<LogicalVariable> vars, List<Mutable<ILogicalExpression>> assignExpressions, List<Mutable<ILogicalExpression>> varRefs, IVariableContext context, SourceLocation sourceLoc) { VariableReferenceExpression dummyVarRef = new VariableReferenceExpression(DUMMY_VAR); dummyVarRef.setSourceLocation(sourceLoc); ScalarFunctionCallExpression f = createFieldAccessExpression(dummyVarRef, field, sourceLoc); f.substituteVar(DUMMY_VAR, resVar); assignExpressions.add(new MutableObject<ILogicalExpression>(f)); LogicalVariable v = context.newVar(); vars.add(v); if (varRefs != null) { VariableReferenceExpression vRef = new VariableReferenceExpression(v); vRef.setSourceLocation(sourceLoc); varRefs.add(new MutableObject<ILogicalExpression>(vRef)); } }
private static void writeVarList(List<LogicalVariable> varList, List<Mutable<ILogicalExpression>> funcArgs) { Mutable<ILogicalExpression> numKeysRef = new MutableObject<>(new ConstantExpression(new AsterixConstantValue(new AInt32(varList.size())))); funcArgs.add(numKeysRef); for (LogicalVariable keyVar : varList) { Mutable<ILogicalExpression> keyVarRef = new MutableObject<>(new VariableReferenceExpression(keyVar)); funcArgs.add(keyVarRef); } }
private void setPrimaryFilterVar(UnnestMapOperator primaryOp, LogicalVariable minFilterVar, LogicalVariable maxFilterVar, IOptimizationContext context) throws AlgebricksException { primaryOp.setMinFilterVars(Collections.singletonList(minFilterVar)); primaryOp.setMaxFilterVars(Collections.singletonList(maxFilterVar)); VariableReferenceExpression minFilterVarRef = new VariableReferenceExpression(minFilterVar); minFilterVarRef.setSourceLocation(primaryOp.getSourceLocation()); VariableReferenceExpression maxFilterVarRef = new VariableReferenceExpression(maxFilterVar); maxFilterVarRef.setSourceLocation(primaryOp.getSourceLocation()); List<Mutable<ILogicalExpression>> indexFilterExpression = Arrays.asList(new MutableObject<>(minFilterVarRef), new MutableObject<>(maxFilterVarRef)); primaryOp.setAdditionalFilteringExpressions(indexFilterExpression); context.computeAndSetTypeEnvironmentForOperator(primaryOp); }
private ILogicalExpression createEqExpr(LogicalVariable lhsVar, IAObject rhsValue, SourceLocation sourceLoc) throws CompilationException { VariableReferenceExpression lhsExpr = new VariableReferenceExpression(lhsVar); lhsExpr.setSourceLocation(sourceLoc); ILogicalExpression rhsExpr = translateConstantValue(rhsValue, sourceLoc); AbstractFunctionCallExpression opExpr = createFunctionCallExpressionForBuiltinOperator(OperatorType.EQ, sourceLoc); opExpr.getArguments().add(new MutableObject<>(lhsExpr)); opExpr.getArguments().add(new MutableObject<>(rhsExpr)); return opExpr; }
private boolean testAndModifyRedundantOp(AssignOperator access, AbstractLogicalOperator op2) { if (op2.getOperatorTag() != LogicalOperatorTag.ASSIGN) { return false; } AssignOperator a2 = (AssignOperator) op2; ILogicalExpression accessExpr0 = getFirstExpr(access); if (accessExpr0.equals(getFirstExpr(a2))) { VariableReferenceExpression varRef = new VariableReferenceExpression(a2.getVariables().get(0)); varRef.setSourceLocation(accessExpr0.getSourceLocation()); access.getExpressions().get(0).setValue(varRef); return true; } else { return false; } }
public static void resetLOJMissingPlaceholderVarInGroupByOp(AccessMethodAnalysisContext analysisCtx, LogicalVariable newMissingPlaceholderVaraible, IOptimizationContext context) throws AlgebricksException { //reset the missing placeholder variable in groupby operator ScalarFunctionCallExpression isMissingFuncExpr = analysisCtx.getLOJIsMissingFuncInGroupBy(); isMissingFuncExpr.getArguments().clear(); VariableReferenceExpression newMissingVarRef = new VariableReferenceExpression(newMissingPlaceholderVaraible); newMissingVarRef.setSourceLocation(isMissingFuncExpr.getSourceLocation()); isMissingFuncExpr.getArguments().add(new MutableObject<ILogicalExpression>(newMissingVarRef)); //recompute type environment. OperatorPropertiesUtil.typeOpRec(analysisCtx.getLOJGroupbyOpRef(), context); }
protected void writeVarList(List<LogicalVariable> varList, List<Mutable<ILogicalExpression>> funcArgs) { Mutable<ILogicalExpression> numKeysRef = new MutableObject<>(new ConstantExpression(new AsterixConstantValue(new AInt32(varList.size())))); funcArgs.add(numKeysRef); for (LogicalVariable keyVar : varList) { VariableReferenceExpression keyVarRef = new VariableReferenceExpression(keyVar); funcArgs.add(new MutableObject<>(keyVarRef)); } }
private Pair<ILogicalOperator, LogicalVariable> createUnnestForAggregatedList(LogicalVariable aggVar, SourceLocation sourceLoc) { LogicalVariable unnestVar = context.newVar(); // Creates an unnest function expression. VariableReferenceExpression aggVarRef = new VariableReferenceExpression(aggVar); aggVarRef.setSourceLocation(sourceLoc); Mutable<ILogicalExpression> unnestArg = new MutableObject<>(aggVarRef); List<Mutable<ILogicalExpression>> unnestArgList = new ArrayList<>(); unnestArgList.add(unnestArg); UnnestingFunctionCallExpression unnestExpr = new UnnestingFunctionCallExpression( FunctionUtil.getFunctionInfo(BuiltinFunctions.SCAN_COLLECTION), unnestArgList); unnestExpr.setSourceLocation(sourceLoc); UnnestOperator unnestOp = new UnnestOperator(unnestVar, new MutableObject<>(unnestExpr)); unnestOp.setSourceLocation(sourceLoc); return new Pair<>(unnestOp, unnestVar); }
private static ForwardOperator createForward(String rangeMapKey, LogicalVariable rangeMapVariable, MutableObject<ILogicalOperator> exchangeOpFromReplicate, MutableObject<ILogicalOperator> globalAggInput, IOptimizationContext context, SourceLocation sourceLocation) throws AlgebricksException { AbstractLogicalExpression rangeMapExpression = new VariableReferenceExpression(rangeMapVariable); rangeMapExpression.setSourceLocation(sourceLocation); ForwardOperator forwardOperator = new ForwardOperator(rangeMapKey, new MutableObject<>(rangeMapExpression)); forwardOperator.setSourceLocation(sourceLocation); forwardOperator.setPhysicalOperator(new ForwardPOperator()); forwardOperator.getInputs().add(exchangeOpFromReplicate); forwardOperator.getInputs().add(globalAggInput); OperatorManipulationUtil.setOperatorMode(forwardOperator); forwardOperator.recomputeSchema(); context.computeAndSetTypeEnvironmentForOperator(forwardOperator); return forwardOperator; }
protected ILogicalExpression translateVariableRef(VariableExpr varExpr) throws CompilationException { LogicalVariable var = context.getVar(varExpr.getVar().getId()); if (var == null) { throw new CompilationException(ErrorCode.COMPILATION_ILLEGAL_STATE, varExpr.getSourceLocation(), varExpr.toString()); } VariableReferenceExpression varRef = new VariableReferenceExpression(var); varRef.setSourceLocation(varExpr.getSourceLocation()); return varRef; }
protected void buildVarExprList(Collection<LogicalVariable> vars, IOptimizationContext context, GroupByOperator g, List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> outVeList) throws AlgebricksException { SourceLocation sourceLoc = g.getSourceLocation(); for (LogicalVariable ov : vars) { LogicalVariable newVar = context.newVar(); VariableReferenceExpression varExpr = new VariableReferenceExpression(newVar); varExpr.setSourceLocation(sourceLoc); outVeList.add(new Pair<LogicalVariable, Mutable<ILogicalExpression>>(ov, new MutableObject<ILogicalExpression>(varExpr))); for (ILogicalPlan p : g.getNestedPlans()) { for (Mutable<ILogicalOperator> r : p.getRoots()) { OperatorManipulationUtil.substituteVarRec((AbstractLogicalOperator) r.getValue(), ov, newVar, true, context); } } } }