@Override public ILogicalOperator visitUnionOperator(UnionAllOperator op, ILogicalOperator arg) throws AlgebricksException { List<Mutable<ILogicalOperator>> copiedInputs = new ArrayList<>(); for (Mutable<ILogicalOperator> childRef : op.getInputs()) { copiedInputs.add(deepCopyOperatorReference(childRef, null)); } List<List<LogicalVariable>> liveVarsInInputs = new ArrayList<>(); for (Mutable<ILogicalOperator> inputOpRef : copiedInputs) { List<LogicalVariable> liveVars = new ArrayList<>(); VariableUtilities.getLiveVariables(inputOpRef.getValue(), liveVars); liveVarsInInputs.add(liveVars); } List<LogicalVariable> liveVarsInLeftInput = liveVarsInInputs.get(0); List<LogicalVariable> liveVarsInRightInput = liveVarsInInputs.get(1); List<Triple<LogicalVariable, LogicalVariable, LogicalVariable>> copiedTriples = new ArrayList<>(); int index = 0; for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> triple : op.getVariableMappings()) { LogicalVariable producedVar = deepCopyVariable(triple.third); Triple<LogicalVariable, LogicalVariable, LogicalVariable> copiedTriple = new Triple<>(liveVarsInLeftInput.get(index), liveVarsInRightInput.get(index), producedVar); copiedTriples.add(copiedTriple); ++index; } UnionAllOperator opCopy = new UnionAllOperator(copiedTriples); deepCopyInputsAnnotationsAndExecutionMode(op, arg, opCopy); return opCopy; }
@Override public ILogicalOperator visitUnionOperator(UnionAllOperator op, Void arg) throws AlgebricksException { List<Triple<LogicalVariable, LogicalVariable, LogicalVariable>> newVarMap = new ArrayList<>(); List<Triple<LogicalVariable, LogicalVariable, LogicalVariable>> varMap = op.getVariableMappings(); for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> triple : varMap) { newVarMap.add(new Triple<>(triple.first, triple.second, triple.third)); } return new UnionAllOperator(newVarMap); }
private AssignOperator createAssignBelowUnionAllBranch(UnionAllOperator unionOp, int inputIndex, AssignOperator originalAssignOp, Set<LogicalVariable> assignUsedVars, IOptimizationContext context) throws AlgebricksException { AssignOperator newAssignOp = cloneAssignOperator(originalAssignOp, context); newAssignOp.getInputs() .add(new MutableObject<ILogicalOperator>(unionOp.getInputs().get(inputIndex).getValue())); unionOp.getInputs().get(inputIndex).setValue(newAssignOp); int numVarMappings = unionOp.getVariableMappings().size(); for (int i = 0; i < numVarMappings; i++) { Triple<LogicalVariable, LogicalVariable, LogicalVariable> varMapping = unionOp.getVariableMappings().get(i); if (assignUsedVars.contains(varMapping.third)) { LogicalVariable replacementVar; if (inputIndex == 0) { replacementVar = varMapping.first; } else { replacementVar = varMapping.second; } VariableUtilities.substituteVariables(newAssignOp, varMapping.third, replacementVar, context); } } context.computeAndSetTypeEnvironmentForOperator(newAssignOp); return newAssignOp; }
unionAllOp = new UnionAllOperator(unionVarMap); unionAllOp.setSourceLocation(sourceLoc); unionAllOp.getInputs().add(new MutableObject<ILogicalOperator>(newSelectOpInLeftPath)); unionAllOp.getInputs().add(new MutableObject<ILogicalOperator>(currentTopOpInRightPath)); unionAllOp.setExecutionMode(ExecutionMode.PARTITIONED); context.computeAndSetTypeEnvironmentForOperator(unionAllOp);
@Override public Void visitUnionOperator(UnionAllOperator op, Void arg) throws AlgebricksException { for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> t : op.getVariableMappings()) { producedVariables.add(t.third); } return null; }
topUnionAllOp = new UnionAllOperator(varTriples); topUnionAllOp.getInputs().add(leftInputBranch); topUnionAllOp.getInputs().add(inputOpRefIterator.next()); topUnionAllOp.setSourceLocation(sourceLoc);
unnestOpRef.getVariables().get(0)); varMap.add(union_triple_vars); UnionAllOperator unionOpFinal = new UnionAllOperator(varMap); unionOpFinal.getInputs().add(new MutableObject<ILogicalOperator>(unnest1)); unionOpFinal.getInputs().add(new MutableObject<ILogicalOperator>(unnest2));
private void insertProjectOperator(UnionAllOperator opUnion, int branch, ArrayList<LogicalVariable> usedVariables, IOptimizationContext context) throws AlgebricksException { ProjectOperator projectOp = new ProjectOperator(usedVariables); ILogicalOperator inputOp = opUnion.getInputs().get(branch).getValue(); projectOp.getInputs().add(new MutableObject<ILogicalOperator>(inputOp)); opUnion.getInputs().get(branch).setValue(projectOp); projectOp.setPhysicalOperator(new StreamProjectPOperator()); projectOp.setExecutionMode(inputOp.getExecutionMode()); context.computeAndSetTypeEnvironmentForOperator(projectOp); context.computeAndSetTypeEnvironmentForOperator(inputOp); }
@Override public IVariableTypeEnvironment computeOutputTypeEnvironment(ITypingContext ctx) throws AlgebricksException { IVariableTypeEnvironment env = new NonPropagatingTypeEnvironment(ctx.getExpressionTypeComputer(), ctx.getMetadataProvider()); IVariableTypeEnvironment envLeft = ctx.getOutputTypeEnvironment(inputs.get(0).getValue()); IVariableTypeEnvironment envRight = ctx.getOutputTypeEnvironment(inputs.get(1).getValue()); if (envLeft == null) { throw new AlgebricksException("Left input types for union operator are not computed."); } for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> t : varMap) { Object typeFromLeft = getType(envLeft, t.first); Object typeFromRight = getType(envRight, t.second); if (typeFromLeft.equals(typeFromRight)) { env.setVarType(t.third, typeFromLeft); } else { env.setVarType(t.third, ctx.getConflictingTypeResolver().resolve(typeFromLeft, typeFromRight)); } } return env; }
@Override public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException { AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue(); if (op.getOperatorTag() != LogicalOperatorTag.UNIONALL) { return false; } UnionAllOperator opUnion = (UnionAllOperator) op; List<Triple<LogicalVariable, LogicalVariable, LogicalVariable>> varMap = opUnion.getVariableMappings(); ArrayList<LogicalVariable> usedVariablesFromOne = new ArrayList<>(); ArrayList<LogicalVariable> usedVariablesFromTwo = new ArrayList<>(); for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> triple : varMap) { usedVariablesFromOne.add(triple.first); usedVariablesFromTwo.add(triple.second); } ArrayList<LogicalVariable> inputSchemaOne = new ArrayList<>(); VariableUtilities.getLiveVariables(opUnion.getInputs().get(0).getValue(), inputSchemaOne); ArrayList<LogicalVariable> inputSchemaTwo = new ArrayList<>(); VariableUtilities.getLiveVariables(opUnion.getInputs().get(1).getValue(), inputSchemaTwo); boolean rewritten = false; if (!isIdentical(usedVariablesFromOne, inputSchemaOne)) { insertProjectOperator(opUnion, 0, usedVariablesFromOne, context); rewritten = true; } if (!isIdentical(usedVariablesFromTwo, inputSchemaTwo)) { insertProjectOperator(opUnion, 1, usedVariablesFromTwo, context); rewritten = true; } return rewritten; }
indexSubTreeVar)); UnionAllOperator unionAllOp = new UnionAllOperator(varMap); unionAllOp.setSourceLocation(topOp.getSourceLocation()); unionAllOp.getInputs().add(new MutableObject<ILogicalOperator>(topOp)); unionAllOp.getInputs().add(panicJoinRef); unionAllOp.setExecutionMode(ExecutionMode.PARTITIONED); context.computeAndSetTypeEnvironmentForOperator(unionAllOp); topOp = unionAllOp;
@Override public Void visitUnionOperator(UnionAllOperator op, Void arg) { for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> m : op.getVariableMappings()) { if (!usedVariables.contains(m.first)) { usedVariables.add(m.first); } if (!usedVariables.contains(m.second)) { usedVariables.add(m.second); } } return null; }
((UnionAllOperator) unionAllOp).getVariableMappings(); UnionAllOperator newUnionAllOp = new UnionAllOperator(varMap); newUnionAllOp.getInputs() .add(new MutableObject<ILogicalOperator>(unionAllOp.getInputs().get(0).getValue())); newUnionAllOp.getInputs() .add(new MutableObject<ILogicalOperator>(unionAllOp.getInputs().get(1).getValue())); context.computeAndSetTypeEnvironmentForOperator(newUnionAllOp);
for (int j = 0; j < unionOp.getInputs().size(); j++) { newAssignOps[j] = createAssignBelowUnionAllBranch(unionOp, j, assignOp, assignUsedVars, context); Triple<LogicalVariable, LogicalVariable, LogicalVariable> varMapping = new Triple<LogicalVariable, LogicalVariable, LogicalVariable>(first, second, assignVars.get(j)); unionOp.getVariableMappings().add(varMapping);
private boolean replaceUnionAllVars(UnionAllOperator op) throws AlgebricksException { boolean modified = false; for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> varMapping : op.getVariableMappings()) { List<LogicalVariable> firstEquivalentVars = equivalentVarsMap.get(varMapping.first); List<LogicalVariable> secondEquivalentVars = equivalentVarsMap.get(varMapping.second); // Replace variables with their representative. if (firstEquivalentVars != null) { varMapping.first = firstEquivalentVars.get(0); modified = true; } if (secondEquivalentVars != null) { varMapping.second = secondEquivalentVars.get(0); modified = true; } } return modified; }
Mutable<ILogicalOperator> branchOpRef = op.getInputs().get(childIndex); ILogicalOperator branchOp = branchOpRef.getValue(); IVariableTypeEnvironment childEnv = context.getOutputTypeEnvironment(branchOp); List<Triple<LogicalVariable, LogicalVariable, LogicalVariable>> triples = op.getVariableMappings(); for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> triple : triples) { LogicalVariable producedVar = triple.third;
private boolean removeUnusedVarsFromUnionAll(UnionAllOperator unionOp, Set<LogicalVariable> toRemove) { Iterator<Triple<LogicalVariable, LogicalVariable, LogicalVariable>> iter = unionOp.getVariableMappings().iterator(); boolean modified = false; if (toRemove != null && !toRemove.isEmpty()) { while (iter.hasNext()) { Triple<LogicalVariable, LogicalVariable, LogicalVariable> varMapping = iter.next(); if (toRemove.contains(varMapping.third)) { iter.remove(); assignedVarSet.remove(varMapping.third); modified = true; } else { // In case when the output variable of Union is survived, // the source variables should not be removed. survivedUnionSourceVarSet.add(varMapping.first); survivedUnionSourceVarSet.add(varMapping.second); } } } return modified; }
@Override public String visitUnionOperator(UnionAllOperator op, Boolean showDetails) throws AlgebricksException { stringBuilder.setLength(0); stringBuilder.append("union"); for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> v : op.getVariableMappings()) { stringBuilder.append(" (").append(v.first).append(", ").append(v.second).append(", ").append(v.third) .append(")"); } appendSchema(op, showDetails); appendAnnotations(op, showDetails); appendPhysicalOperatorInfo(op, showDetails); return stringBuilder.toString(); }
@Override public Boolean visitUnionOperator(UnionAllOperator op, ILogicalOperator arg) throws AlgebricksException { AbstractLogicalOperator aop = (AbstractLogicalOperator) arg; if (aop.getOperatorTag() != LogicalOperatorTag.UNIONALL) { return Boolean.FALSE; } UnionAllOperator unionOpArg = (UnionAllOperator) copyAndSubstituteVar(op, arg); List<Triple<LogicalVariable, LogicalVariable, LogicalVariable>> mapping = op.getVariableMappings(); List<Triple<LogicalVariable, LogicalVariable, LogicalVariable>> mappingArg = unionOpArg.getVariableMappings(); if (mapping.size() != mappingArg.size()) { return Boolean.FALSE; } return VariableUtilities.varListEqualUnordered(mapping, mappingArg); }
private void mapVariablesForUnion(ILogicalOperator op, ILogicalOperator arg) { if (op.getOperatorTag() != arg.getOperatorTag()) { return; } UnionAllOperator union = (UnionAllOperator) op; UnionAllOperator unionArg = (UnionAllOperator) arg; mapVarTripleList(union.getVariableMappings(), unionArg.getVariableMappings()); }