@Override public DualInputPlanNode instantiate(Channel in1, Channel in2, TwoInputNode node) { if (node instanceof SinkJoiner) { return new SinkJoinerPlanNode((SinkJoiner) node, in1, in2); } else { throw new CompilerException(); } }
public void getDataSinks(List<SinkPlanNode> sinks) { final PlanNode in1 = this.input1.getSource(); final PlanNode in2 = this.input2.getSource(); if (in1 instanceof SinkPlanNode) { sinks.add((SinkPlanNode) in1); } else if (in1 instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) in1).getDataSinks(sinks); } else { throw new CompilerException("Illegal child node for a sink joiner utility node: Neither Sink nor Sink Joiner"); } if (in2 instanceof SinkPlanNode) { sinks.add((SinkPlanNode) in2); } else if (in2 instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) in2).getDataSinks(sinks); } else { throw new CompilerException("Illegal child node for a sink joiner utility node: Neither Sink nor Sink Joiner"); } } }
public void setCosts(Costs nodeCosts) { // the plan enumeration logic works as for regular two-input-operators, which is important // because of the branch handling logic. it does pick redistributing network channels // between the sink and the sink joiner, because sinks joiner has a different parallelism than the sink. // we discard any cost and simply use the sum of the costs from the two children. Costs totalCosts = getInput1().getSource().getCumulativeCosts().clone(); totalCosts.addCosts(getInput2().getSource().getCumulativeCosts()); super.setCosts(totalCosts); }
public void setCosts(Costs nodeCosts) { // the plan enumeration logic works as for regular two-input-operators, which is important // because of the branch handling logic. it does pick redistributing network channels // between the sink and the sink joiner, because sinks joiner has a different parallelism than the sink. // we discard any cost and simply use the sum of the costs from the two children. Costs totalCosts = getInput1().getSource().getCumulativeCosts().clone(); totalCosts.addCosts(getInput2().getSource().getCumulativeCosts()); super.setCosts(totalCosts); }
bestPlanSinks.add((SinkPlanNode) bestPlanRoot); } else if (bestPlanRoot instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) bestPlanRoot).getDataSinks(bestPlanSinks);
@Override public DualInputPlanNode instantiate(Channel in1, Channel in2, TwoInputNode node) { if (node instanceof SinkJoiner) { return new SinkJoinerPlanNode((SinkJoiner) node, in1, in2); } else { throw new CompilerException(); } }
public void setCosts(Costs nodeCosts) { // the plan enumeration logic works as for regular two-input-operators, which is important // because of the branch handling logic. it does pick redistributing network channels // between the sink and the sink joiner, because sinks joiner has a different parallelism than the sink. // we discard any cost and simply use the sum of the costs from the two children. Costs totalCosts = getInput1().getSource().getCumulativeCosts().clone(); totalCosts.addCosts(getInput2().getSource().getCumulativeCosts()); super.setCosts(totalCosts); }
public void getDataSinks(List<SinkPlanNode> sinks) { final PlanNode in1 = this.input1.getSource(); final PlanNode in2 = this.input2.getSource(); if (in1 instanceof SinkPlanNode) { sinks.add((SinkPlanNode) in1); } else if (in1 instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) in1).getDataSinks(sinks); } else { throw new CompilerException("Illegal child node for a sink joiner utility node: Neither Sink nor Sink Joiner"); } if (in2 instanceof SinkPlanNode) { sinks.add((SinkPlanNode) in2); } else if (in2 instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) in2).getDataSinks(sinks); } else { throw new CompilerException("Illegal child node for a sink joiner utility node: Neither Sink nor Sink Joiner"); } } }
@Override public DualInputPlanNode instantiate(Channel in1, Channel in2, TwoInputNode node) { if (node instanceof SinkJoiner) { return new SinkJoinerPlanNode((SinkJoiner) node, in1, in2); } else { throw new CompilerException(); } }
public void setCosts(Costs nodeCosts) { // the plan enumeration logic works as for regular two-input-operators, which is important // because of the branch handling logic. it does pick redistributing network channels // between the sink and the sink joiner, because sinks joiner has a different parallelism than the sink. // we discard any cost and simply use the sum of the costs from the two children. Costs totalCosts = getInput1().getSource().getCumulativeCosts().clone(); totalCosts.addCosts(getInput2().getSource().getCumulativeCosts()); super.setCosts(totalCosts); }
public void getDataSinks(List<SinkPlanNode> sinks) { final PlanNode in1 = this.input1.getSource(); final PlanNode in2 = this.input2.getSource(); if (in1 instanceof SinkPlanNode) { sinks.add((SinkPlanNode) in1); } else if (in1 instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) in1).getDataSinks(sinks); } else { throw new CompilerException("Illegal child node for a sink joiner utility node: Neither Sink nor Sink Joiner"); } if (in2 instanceof SinkPlanNode) { sinks.add((SinkPlanNode) in2); } else if (in2 instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) in2).getDataSinks(sinks); } else { throw new CompilerException("Illegal child node for a sink joiner utility node: Neither Sink nor Sink Joiner"); } } }
@Override public DualInputPlanNode instantiate(Channel in1, Channel in2, TwoInputNode node) { if (node instanceof SinkJoiner) { return new SinkJoinerPlanNode((SinkJoiner) node, in1, in2); } else { throw new CompilerException(); } }
public void setCosts(Costs nodeCosts) { // the plan enumeration logic works as for regular two-input-operators, which is important // because of the branch handling logic. it does pick redistributing network channels // between the sink and the sink joiner, because sinks joiner has a different parallelism than the sink. // we discard any cost and simply use the sum of the costs from the two children. Costs totalCosts = getInput1().getSource().getCumulativeCosts().clone(); totalCosts.addCosts(getInput2().getSource().getCumulativeCosts()); super.setCosts(totalCosts); }
public void getDataSinks(List<SinkPlanNode> sinks) { final PlanNode in1 = this.input1.getSource(); final PlanNode in2 = this.input2.getSource(); if (in1 instanceof SinkPlanNode) { sinks.add((SinkPlanNode) in1); } else if (in1 instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) in1).getDataSinks(sinks); } else { throw new CompilerException("Illegal child node for a sink joiner utility node: Neither Sink nor Sink Joiner"); } if (in2 instanceof SinkPlanNode) { sinks.add((SinkPlanNode) in2); } else if (in2 instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) in2).getDataSinks(sinks); } else { throw new CompilerException("Illegal child node for a sink joiner utility node: Neither Sink nor Sink Joiner"); } } }
@Override public DualInputPlanNode instantiate(Channel in1, Channel in2, TwoInputNode node) { if (node instanceof SinkJoiner) { return new SinkJoinerPlanNode((SinkJoiner) node, in1, in2); } else { throw new CompilerException(); } }
public void getDataSinks(List<SinkPlanNode> sinks) { final PlanNode in1 = this.input1.getSource(); final PlanNode in2 = this.input2.getSource(); if (in1 instanceof SinkPlanNode) { sinks.add((SinkPlanNode) in1); } else if (in1 instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) in1).getDataSinks(sinks); } else { throw new CompilerException("Illegal child node for a sink joiner utility node: Neither Sink nor Sink Joiner"); } if (in2 instanceof SinkPlanNode) { sinks.add((SinkPlanNode) in2); } else if (in2 instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) in2).getDataSinks(sinks); } else { throw new CompilerException("Illegal child node for a sink joiner utility node: Neither Sink nor Sink Joiner"); } } }
bestPlanSinks.add((SinkPlanNode) bestPlanRoot); } else if (bestPlanRoot instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) bestPlanRoot).getDataSinks(bestPlanSinks);
bestPlanSinks.add((SinkPlanNode) bestPlanRoot); } else if (bestPlanRoot instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) bestPlanRoot).getDataSinks(bestPlanSinks);
bestPlanSinks.add((SinkPlanNode) bestPlanRoot); } else if (bestPlanRoot instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) bestPlanRoot).getDataSinks(bestPlanSinks);
bestPlanSinks.add((SinkPlanNode) bestPlanRoot); } else if (bestPlanRoot instanceof SinkJoinerPlanNode) { ((SinkJoinerPlanNode) bestPlanRoot).getDataSinks(bestPlanSinks);