private void copySourceLocation(ILogicalExpression src, AbstractLogicalExpression dest) { dest.setSourceLocation(src.getSourceLocation()); }
private void deepCopyExpressionRefs(List<Mutable<ILogicalExpression>> newExprs, List<Mutable<ILogicalExpression>> oldExprs) { for (Mutable<ILogicalExpression> oldExpr : oldExprs) { newExprs.add(new MutableObject<>(((AbstractLogicalExpression) oldExpr.getValue()).cloneExpression())); } }
private boolean isEquiJoin(Mutable<ILogicalExpression> conditionExpr) { AbstractLogicalExpression expr = (AbstractLogicalExpression) conditionExpr.getValue(); if (expr.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) { AbstractFunctionCallExpression funcExpr = (AbstractFunctionCallExpression) expr; FunctionIdentifier funcIdent = funcExpr.getFunctionIdentifier(); if (funcIdent != AlgebricksBuiltinFunctions.AND && funcIdent != AlgebricksBuiltinFunctions.EQ) { return false; } } return true; } }
if (expr.isFunctional()) { Set<LogicalVariable> liveVars = new HashSet<>(); List<LogicalVariable> usedVars = new ArrayList<>(); VariableReferenceExpression varRef = new VariableReferenceExpression(exprEqClass.getVariable()); varRef.setSourceLocation(expr.getSourceLocation()); exprRef.setValue(varRef); if (expr.isFunctional() && assignCommonExpression(exprEqClass, expr)) { VariableReferenceExpression varRef = new VariableReferenceExpression(exprEqClass.getVariable()); varRef.setSourceLocation(expr.getSourceLocation()); exprRef.setValue(varRef); if (expr.getExpressionTag() != LogicalExpressionTag.VARIABLE && expr.getExpressionTag() != LogicalExpressionTag.CONSTANT) { exprEqClass = new ExprEquivalenceClass(op, exprRef); exprEqClassMap.put(expr, exprEqClass); if (expr.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) { AbstractFunctionCallExpression funcExpr = (AbstractFunctionCallExpression) expr; for (Mutable<ILogicalExpression> arg : funcExpr.getArguments()) {
expr = (AbstractLogicalExpression) assignOp.getExpressions().get(varIndex).getValue(); if (expr == null || expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) { return null; expr.getUsedVariables(usedVars); LogicalVariable usedVar = usedVars.get(0); List<String> returnList = new ArrayList<>();
@Override public boolean transform(Mutable<ILogicalExpression> exprRef) throws AlgebricksException { AbstractLogicalExpression expr = (AbstractLogicalExpression) exprRef.getValue(); Pair<Boolean, ILogicalExpression> p = expr.accept(this, null); if (p.first) { exprRef.setValue(p.second); } return p.first; }
expr = (AbstractLogicalExpression) assignOp.getExpressions().get(assignVarIndex).getValue(); if (expr.getExpressionTag() == LogicalExpressionTag.CONSTANT) { return Collections.emptyList(); UnnestOperator unnestOp = (UnnestOperator) op; expr = (AbstractLogicalExpression) unnestOp.getExpressionRef().getValue(); if (expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) { return Collections.emptyList(); if (expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) { return Collections.emptyList(); LogicalVariable var = varList.get(varIndex); ArrayList<LogicalVariable> parentVars = new ArrayList<>(); expr.getUsedVariables(parentVars);
@Override public boolean transform(Mutable<ILogicalExpression> exprRef) throws AlgebricksException { AbstractLogicalExpression expr = (AbstractLogicalExpression) exprRef.getValue(); ClosedDataInfo cdi = expr.accept(this, null); if (cdi.expressionChanged) { exprRef.setValue(cdi.expression); } return cdi.expressionChanged; }
partFields.forEach(f -> { AbstractLogicalExpression sampledField = new VariableReferenceExpression(f.getColumn()); sampledField.setSourceLocation(sourceLocation); sampledFields.add(new MutableObject<>(sampledField)); }); samplingResultVarExp.setSourceLocation(sourceLocation); arg.add(new MutableObject<>(samplingResultVarExp));
private void gatherFunctionCalls(Mutable<ILogicalExpression> exprRef, List<Mutable<ILogicalExpression>> funcExprs) { AbstractLogicalExpression expr = (AbstractLogicalExpression) exprRef.getValue(); if (expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) { return; } // Check whether the function is a function we want to push. AbstractFunctionCallExpression funcExpr = (AbstractFunctionCallExpression) expr; if (toPushFuncIdents.contains(funcExpr.getFunctionIdentifier())) { funcExprs.add(exprRef); } // Traverse arguments. for (Mutable<ILogicalExpression> funcArg : funcExpr.getArguments()) { gatherFunctionCalls(funcArg, funcExprs); } }
private Mutable<ILogicalExpression> deepCopyExpressionRef(Mutable<ILogicalExpression> oldExpr) { return new MutableObject<ILogicalExpression>( ((AbstractLogicalExpression) oldExpr.getValue()).cloneExpression()); }
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; }
@Override public boolean transform(Mutable<ILogicalExpression> exprRef) { ILogicalExpression e = exprRef.getValue(); switch (((AbstractLogicalExpression) e).getExpressionTag()) { case VARIABLE: {
@Override public ILogicalOperator visitTokenizeOperator(TokenizeOperator op, Void arg) throws AlgebricksException { List<Mutable<ILogicalExpression>> newPrimaryKeyExpressions = new ArrayList<>(); deepCopyExpressionRefs(newPrimaryKeyExpressions, op.getPrimaryKeyExpressions()); List<Mutable<ILogicalExpression>> newSecondaryKeyExpressions = new ArrayList<>(); deepCopyExpressionRefs(newSecondaryKeyExpressions, op.getSecondaryKeyExpressions()); List<LogicalVariable> newTokenizeVars = new ArrayList<>(); deepCopyVars(newTokenizeVars, op.getTokenizeVars()); Mutable<ILogicalExpression> newFilterExpression = new MutableObject<>(((AbstractLogicalExpression) op.getFilterExpression()).cloneExpression()); List<Object> newTokenizeVarTypes = new ArrayList<>(); deepCopyObjects(newTokenizeVarTypes, op.getTokenizeVarTypes()); TokenizeOperator tokenizeOp = new TokenizeOperator(op.getDataSourceIndex(), newPrimaryKeyExpressions, newSecondaryKeyExpressions, newTokenizeVars, newFilterExpression, op.getOperation(), op.isBulkload(), op.isPartitioned(), newTokenizeVarTypes); return tokenizeOp; }
Pair<ILogicalOperator, LogicalVariable> frameOffsetResult = winFrameOffsetExpr.accept(this, currentOpRef); frameOffsetExpr = new VariableReferenceExpression(frameOffsetResult.second); frameOffsetExpr.setSourceLocation(sourceLoc); currentOpRef = new MutableObject<>(frameOffsetResult.first); } else if (makeRunningAgg) { resultExpr = new VariableReferenceExpression(runningAggResultVar); resultExpr.setSourceLocation(sourceLoc); } else if (makeNestedAgg) { resultExpr = new VariableReferenceExpression(nestedAggResultVar); resultExpr.setSourceLocation(sourceLoc); } else { throw new CompilationException(ErrorCode.COMPILATION_ILLEGAL_STATE, sourceLoc, "");
private static ILogicalExpression resolveFieldExpression(AbstractLogicalExpression constr, Object accessKey, IVariableTypeEnvironment typeEnvironment, FieldResolver resolver) throws AlgebricksException { if (constr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) { return null; } AbstractFunctionCallExpression fce = (AbstractFunctionCallExpression) constr; if (!fce.getFunctionIdentifier().equals(BuiltinFunctions.OPEN_RECORD_CONSTRUCTOR) && !fce.getFunctionIdentifier().equals(BuiltinFunctions.CLOSED_RECORD_CONSTRUCTOR)) { return null; } return resolver.resolve(accessKey, fce, typeEnvironment); }
@Override public ILogicalOperator visitIndexInsertDeleteUpsertOperator(IndexInsertDeleteUpsertOperator op, Void arg) throws AlgebricksException { List<Mutable<ILogicalExpression>> newPrimaryKeyExpressions = new ArrayList<>(); deepCopyExpressionRefs(newPrimaryKeyExpressions, op.getPrimaryKeyExpressions()); List<Mutable<ILogicalExpression>> newSecondaryKeyExpressions = new ArrayList<>(); deepCopyExpressionRefs(newSecondaryKeyExpressions, op.getSecondaryKeyExpressions()); Mutable<ILogicalExpression> newFilterExpression = new MutableObject<>(((AbstractLogicalExpression) op.getFilterExpression()).cloneExpression()); List<Mutable<ILogicalExpression>> newLSMComponentFilterExpressions = new ArrayList<>(); deepCopyExpressionRefs(newLSMComponentFilterExpressions, op.getAdditionalFilteringExpressions()); IndexInsertDeleteUpsertOperator indexInsertDeleteOp = new IndexInsertDeleteUpsertOperator( op.getDataSourceIndex(), newPrimaryKeyExpressions, newSecondaryKeyExpressions, newFilterExpression, op.getOperation(), op.isBulkload(), op.getNumberOfAdditionalNonFilteringFields()); indexInsertDeleteOp.setAdditionalFilteringExpressions(newLSMComponentFilterExpressions); return indexInsertDeleteOp; }
if (expr1.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) { AbstractFunctionCallExpression f = (AbstractFunctionCallExpression) expr1;