private Map<LogicalVariable, EquivalenceClass> getOrComputeEqClasses(ILogicalOperator op, IOptimizationContext ctx) throws AlgebricksException { Map<LogicalVariable, EquivalenceClass> eqClasses = ctx.getEquivalenceClassMap(op); if (eqClasses == null) { op.accept(this, ctx); eqClasses = ctx.getEquivalenceClassMap(op); } return eqClasses; }
private long getOperatorRequiredMemory(ILogicalOperator op, long memorySize) { if (op.getExecutionMode() == AbstractLogicalOperator.ExecutionMode.PARTITIONED || op.getExecutionMode() == AbstractLogicalOperator.ExecutionMode.LOCAL) { return memorySize * numComputationPartitions; } return memorySize; }
@Override public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException { ILogicalOperator op = opRef.getValue(); if (context.checkIfInDontApplySet(this, op)) { return false; } op.accept(visitor, null); context.computeAndSetTypeEnvironmentForOperator(op); context.addToDontApplySet(this, op); return false; }
/** * @param recordInAssign the variable reference expression in assign op * @param recordInScan the record (payload) variable in scan op * @return true if the expression in the assign op is a variable and that variable = record variable in scan op */ private boolean sameRecords(ILogicalExpression recordInAssign, LogicalVariable recordInScan) { return recordInAssign != null && recordInAssign.getExpressionTag() == LogicalExpressionTag.VARIABLE && ((VariableReferenceExpression) recordInAssign).getVariableReference().equals(recordInScan); }
@Override public LogicalVariable newVar(String displayName) { varCounter.inc(); int varId = varCounter.get(); LogicalVariable var = new LogicalVariable(varId, displayName); currentVarMap.put(varId, var); return var; }
private void subst(LogicalVariable v1, LogicalVariable v2, List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> varExprPairList) { for (Pair<LogicalVariable, Mutable<ILogicalExpression>> ve : varExprPairList) { if (ve.first != null && ve.first.equals(v1)) { ve.first = v2; return; } ve.second.getValue().substituteVar(v1, v2); } }
@Override public void substituteVar(LogicalVariable v1, LogicalVariable v2) { if (variable.equals(v1)) { variable = v2; } }
@Override public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException { ILogicalOperator op = opRef.getValue(); if (context.checkIfInDontApplySet(this, op)) { return false; } return op.acceptExpressionTransform(cfv); }
public ILogicalExpression deepCopy(ILogicalExpression expr) throws AlgebricksException { if (expr == null) { return null; } return expr.accept(this, null); }
public LogicalVariable createNewVar() { varCounter++; LogicalVariable var = new LogicalVariable(-varCounter); return var; }
@Override public boolean equals(Object obj) { if (obj instanceof LogicalVariable) { return id == ((LogicalVariable) obj).getId(); } return false; }
@Override public String toString() { return column.toString() + "(" + order + ")"; } }
public LangExpressionToPlanTranslator(MetadataProvider metadataProvider, int currentVarCounterValue) throws AlgebricksException { this(metadataProvider, new Counter(currentVarCounterValue)); }
/** * @return the physical properties that this operator delivers, based on * what its children deliver */ @Override public final IPhysicalPropertiesVector getDeliveredPhysicalProperties() { return physicalOperator.getDeliveredProperties(); }
/** * @return for each child, one vector of required physical properties */ @Override public final PhysicalRequirements getRequiredPhysicalPropertiesForChildren( IPhysicalPropertiesVector requiredProperties, IOptimizationContext context) throws AlgebricksException { return physicalOperator.getRequiredPropertiesForChildren(this, requiredProperties, context); }
public int getOperatorRequiredCores(ILogicalOperator operator) { if (operator.getExecutionMode() == AbstractLogicalOperator.ExecutionMode.PARTITIONED || operator.getExecutionMode() == AbstractLogicalOperator.ExecutionMode.LOCAL) { return numComputationPartitions; } return MIN_OPERATOR_CORES; }
@Override public LogicalVariable newVar() { varCounter++; return new LogicalVariable(varCounter); }
@Override public LogicalVariable newVar(String displayName) { varCounter++; return new LogicalVariable(varCounter, displayName); }