@Override public ILogicalOperator visitEmptyTupleSourceOperator(EmptyTupleSourceOperator op, Void arg) throws AlgebricksException { return new EmptyTupleSourceOperator(); }
@Override public ILogicalOperator visitEmptyTupleSourceOperator(EmptyTupleSourceOperator op, ILogicalOperator arg) { EmptyTupleSourceOperator opCopy = new EmptyTupleSourceOperator(); copySourceLocation(op, opCopy); opCopy.setExecutionMode(op.getExecutionMode()); return opCopy; }
@Test public void noBlockingPlan() throws AlgebricksException { EmptyTupleSourceOperator ets = new EmptyTupleSourceOperator(); ets.setExecutionMode(UNPARTITIONED); AssignOperator assignOperator = new AssignOperator(Collections.emptyList(), null); assignOperator.setExecutionMode(UNPARTITIONED); assignOperator.getInputs().add(new MutableObject<>(ets)); ExchangeOperator exchange = new ExchangeOperator(); exchange.setExecutionMode(UNPARTITIONED); exchange.setPhysicalOperator(new OneToOneExchangePOperator()); exchange.getInputs().add(new MutableObject<>(assignOperator)); DistributeResultOperator resultOperator = new DistributeResultOperator(null, null); resultOperator.setExecutionMode(UNPARTITIONED); resultOperator.getInputs().add(new MutableObject<>(exchange)); ALogicalPlanImpl plan = new ALogicalPlanImpl(Collections.singletonList(new MutableObject(resultOperator))); List<PlanStage> stages = ResourceUtils.getStages(plan); // ensure a single stage plan final int expectedStages = 1; Assert.assertEquals(expectedStages, stages.size()); validateStages(stages, resultOperator, exchange, ets, assignOperator); // frame size for every operator final long expectedMemory = stages.get(0).getOperators().size() * FRAME_SIZE; assertRequiredMemory(stages, expectedMemory); }
@Test public void testJoinGroupby() throws AlgebricksException { EmptyTupleSourceOperator ets1 = new EmptyTupleSourceOperator(); ets1.setExecutionMode(PARTITIONED); scanOperator1.getInputs().add(new MutableObject<>(ets1)); EmptyTupleSourceOperator ets2 = new EmptyTupleSourceOperator(); ets1.setExecutionMode(PARTITIONED); exchangeOperator1.getInputs().add(new MutableObject<>(firstJoin)); EmptyTupleSourceOperator ets3 = new EmptyTupleSourceOperator(); ets1.setExecutionMode(PARTITIONED);
public static ILogicalOperator eliminateSingleSubplanOverEts(SubplanOperator subplan) { if (subplan.getNestedPlans().size() > 1) { // not a single subplan List<Mutable<ILogicalOperator>> subInpList = subplan.getInputs(); subInpList.clear(); subInpList.add(new MutableObject<ILogicalOperator>(new EmptyTupleSourceOperator())); return subplan; } ILogicalPlan plan = subplan.getNestedPlans().get(0); if (plan.getRoots().size() > 1) { // not a single subplan List<Mutable<ILogicalOperator>> subInpList = subplan.getInputs(); subInpList.clear(); subInpList.add(new MutableObject<ILogicalOperator>(new EmptyTupleSourceOperator())); return subplan; } return plan.getRoots().get(0).getValue(); }
join.getInputs().add(new MutableObject<>(leftChildExchange)); leftChildExchange.getInputs().add(new MutableObject<>(leftChild)); EmptyTupleSourceOperator ets = new EmptyTupleSourceOperator(); ets.setExecutionMode(AbstractLogicalOperator.ExecutionMode.PARTITIONED); leftChild.getInputs().add(new MutableObject<>(ets)); leftChild.getInputs().add(new MutableObject<>(ets));
public ILogicalPlan translate(List<Clause> clauses) throws AlgebricksException, CompilationException { if (clauses == null) { return null; } Mutable<ILogicalOperator> opRef = new MutableObject<ILogicalOperator>(new EmptyTupleSourceOperator()); Pair<ILogicalOperator, LogicalVariable> p = null; for (Clause c : clauses) { p = c.accept(this, opRef); opRef = new MutableObject<ILogicalOperator>(p.first); } ArrayList<Mutable<ILogicalOperator>> globalPlanRoots = new ArrayList<Mutable<ILogicalOperator>>(); ILogicalOperator topOp = p.first; globalPlanRoots.add(new MutableObject<ILogicalOperator>(topOp)); ILogicalPlan plan = new ALogicalPlanImpl(globalPlanRoots); return plan; }
@Test public void testNonBlockingGroupByOrderBy() throws AlgebricksException { EmptyTupleSourceOperator ets = new EmptyTupleSourceOperator(); ets.setExecutionMode(PARTITIONED);
private ILogicalPlan translateMainModule(MainModuleNode moduleNode) throws SystemException { QueryBodyNode qbn = moduleNode.getQueryBody(); ASTNode queryBody = qbn.getExpression(); TranslationContext tCtx = new TranslationContext(null, new EmptyTupleSourceOperator()); LogicalVariable lVar = translateExpression(queryBody, tCtx); LogicalVariable iLVar = newLogicalVariable(); UnnestOperator unnest = new UnnestOperator(iLVar, mutable(ufce(BuiltinOperators.ITERATE, vre(lVar)))); unnest.getInputs().add(mutable(tCtx.op)); List<Mutable<ILogicalExpression>> exprs = new ArrayList<Mutable<ILogicalExpression>>(); exprs.add(mutable(vre(iLVar))); QueryResultSetDataSink sink = new QueryResultSetDataSink(ccb.getResultSetId(), null); DistributeResultOperator op = new DistributeResultOperator(exprs, sink); op.getInputs().add(mutable(unnest)); ALogicalPlanImpl lp = new ALogicalPlanImpl(mutable(op)); return lp; }
@Test public void testUnPartitionedJoin() throws AlgebricksException { IClusterCapacity clusterCapacity = new ClusterCapacity(); RequiredCapacityVisitor visitor = makeComputationCapacityVisitor(PARALLELISM, clusterCapacity); // Constructs a join query plan. InnerJoinOperator join = makeJoinOperator(AbstractLogicalOperator.ExecutionMode.UNPARTITIONED); // Left child plan of the join. ExchangeOperator leftChildExchange = new ExchangeOperator(); leftChildExchange.setExecutionMode(AbstractLogicalOperator.ExecutionMode.UNPARTITIONED); leftChildExchange.setPhysicalOperator(new OneToOneExchangePOperator()); InnerJoinOperator leftChild = makeJoinOperator(AbstractLogicalOperator.ExecutionMode.UNPARTITIONED); join.getInputs().add(new MutableObject<>(leftChildExchange)); leftChildExchange.getInputs().add(new MutableObject<>(leftChild)); EmptyTupleSourceOperator ets = new EmptyTupleSourceOperator(); ets.setExecutionMode(AbstractLogicalOperator.ExecutionMode.UNPARTITIONED); leftChild.getInputs().add(new MutableObject<>(ets)); leftChild.getInputs().add(new MutableObject<>(ets)); // Right child plan of the join. ExchangeOperator rightChildExchange = new ExchangeOperator(); rightChildExchange.setExecutionMode(AbstractLogicalOperator.ExecutionMode.UNPARTITIONED); rightChildExchange.setPhysicalOperator(new OneToOneExchangePOperator()); GroupByOperator rightChild = makeGroupByOperator(AbstractLogicalOperator.ExecutionMode.UNPARTITIONED); join.getInputs().add(new MutableObject<>(rightChildExchange)); rightChildExchange.getInputs().add(new MutableObject<>(rightChild)); rightChild.getInputs().add(new MutableObject<>(ets)); // Verifies the calculated cluster capacity requirement for the test quer plan. join.accept(visitor, null); Assert.assertTrue(clusterCapacity.getAggregatedCores() == 1); Assert.assertTrue(clusterCapacity.getAggregatedMemoryByteSize() == 3 * MEMORY_BUDGET + 5L * FRAME_SIZE); }
public static void ntsToEts(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException { AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue(); if (op.getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE) { EmptyTupleSourceOperator ets = new EmptyTupleSourceOperator(); context.computeAndSetTypeEnvironmentForOperator(ets); opRef.setValue(ets); } else { for (Mutable<ILogicalOperator> i : opRef.getValue().getInputs()) { ntsToEts(i, context); } } }
@Test public void testReplicateSortJoin() throws AlgebricksException { EmptyTupleSourceOperator ets = new EmptyTupleSourceOperator(); ets.setExecutionMode(PARTITIONED);
/** * rewrite NestedTupleSource operators to EmptyTupleSource operators * * @param nestedRootRef */ private void rewriteNestedTupleSource(Mutable<ILogicalOperator> nestedRootRef, IOptimizationContext context) throws AlgebricksException { AbstractLogicalOperator nestedRoot = (AbstractLogicalOperator) nestedRootRef.getValue(); if (nestedRoot.getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE) { ILogicalOperator ets = new EmptyTupleSourceOperator(); nestedRootRef.setValue(ets); context.computeAndSetTypeEnvironmentForOperator(ets); } List<Mutable<ILogicalOperator>> inputs = nestedRoot.getInputs(); for (Mutable<ILogicalOperator> input : inputs) { rewriteNestedTupleSource(input, context); } } }
EmptyTupleSourceOperator ets = new EmptyTupleSourceOperator();
ILogicalOperator etsOp = new EmptyTupleSourceOperator();
public ILogicalPlan translate(Query expr, String outputDatasetName, ICompiledDmlStatement stmt, ILogicalOperator baseOp) throws AlgebricksException { MutableObject<ILogicalOperator> base = new MutableObject<>(new EmptyTupleSourceOperator()); if (baseOp != null) { base = new MutableObject<>(baseOp);
arity); Signature sign = f.getSignature(); TranslationContext tCtx = new TranslationContext(null, new EmptyTupleSourceOperator()); XQueryVariable[] params = new XQueryVariable[arity]; for (int i = 0; i < arity; ++i) {
new MutableObject<>(boundaryOperator), new MutableObject<>(innerBranchOperator)); opRef.setValue(join); ILogicalOperator ets = new EmptyTupleSourceOperator(); context.computeAndSetTypeEnvironmentForOperator(ets); boundaryOpRef.setValue(ets);
EmptyTupleSourceOperator ets = new EmptyTupleSourceOperator(); context.computeAndSetTypeEnvironmentForOperator(ets);