Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.sql.planner;
 
 
 
 import java.util.List;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 {
     private final SplitManager splitManager;
 
     @Inject
     public DistributedExecutionPlanner(SplitManager splitManager)
     {
         this. = checkNotNull(splitManager"splitManager is null");
     }
 
     public StageExecutionPlan plan(SubPlan root)
     {
         PlanFragment currentFragment = root.getFragment();
 
         // get splits for this fragment, this is lazy so split assignments aren't actually calculated here
         Visitor visitor = new Visitor();
         Optional<SplitSourcesplits = currentFragment.getRoot().accept(visitornull);
 
         // create child stages
         ImmutableList.Builder<StageExecutionPlandependencies = ImmutableList.builder();
         for (SubPlan childPlan : root.getChildren()) {
             dependencies.add(plan(childPlan));
         }
 
         return new StageExecutionPlan(currentFragment,
                 splits,
                 dependencies.build()
         );
     }
 
     private final class Visitor
             extends PlanVisitor<VoidOptional<SplitSource>>
     {
         @Override
         public Optional<SplitSourcevisitTableScan(TableScanNode nodeVoid context)
         {
             // get dataSource for table
             SplitSource splitSource = .getPartitionSplits(node.getTable(), getPartitions(node));
 
             return Optional.of(splitSource);
         }
 
         private List<PartitiongetPartitions(TableScanNode node)
         {
             if (node.getGeneratedPartitions().isPresent()) {
                return node.getGeneratedPartitions().get().getPartitions();
            }
            PartitionResult allPartitions = .getPartitions(node.getTable(), Optional.empty());
            return allPartitions.getPartitions();
        }
        @Override
        public Optional<SplitSourcevisitJoin(JoinNode nodeVoid context)
        {
            Optional<SplitSourceleftSplits = node.getLeft().accept(thiscontext);
            Optional<SplitSourcerightSplits = node.getRight().accept(thiscontext);
            if (leftSplits.isPresent() && rightSplits.isPresent()) {
                throw new IllegalArgumentException("Both left and right join nodes are partitioned"); // TODO: "partitioned" may not be the right term
            }
            return leftSplits.isPresent() ? leftSplits : rightSplits;
        }
        @Override
        public Optional<SplitSourcevisitSemiJoin(SemiJoinNode nodeVoid context)
        {
            Optional<SplitSourcesourceSplits = node.getSource().accept(thiscontext);
            Optional<SplitSourcefilteringSourceSplits = node.getFilteringSource().accept(thiscontext);
            if (sourceSplits.isPresent() && filteringSourceSplits.isPresent()) {
                throw new IllegalArgumentException("Both source and filteringSource semi join nodes are partitioned"); // TODO: "partitioned" may not be the right term
            }
            return sourceSplits.isPresent() ? sourceSplits : filteringSourceSplits;
        }
        @Override
        public Optional<SplitSourcevisitIndexJoin(IndexJoinNode nodeVoid context)
        {
            return node.getProbeSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitRemoteSource(RemoteSourceNode nodeVoid context)
        {
            // remote source node does not have splits
            return Optional.empty();
        }
        @Override
        public Optional<SplitSourcevisitValues(ValuesNode nodeVoid context)
        {
            // values node does not have splits
            return Optional.empty();
        }
        @Override
        public Optional<SplitSourcevisitFilter(FilterNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitSample(SampleNode nodeVoid context)
        {
            switch (node.getSampleType()) {
                case :
                case :
                    return node.getSource().accept(thiscontext);
                case :
                    Optional<SplitSourcenodeSplits = node.getSource().accept(thiscontext);
                    if (nodeSplits.isPresent()) {
                        SplitSource sampledSplitSource = new SampledSplitSource(nodeSplits.get(), node.getSampleRatio());
                        return Optional.of(sampledSplitSource);
                    }
                    // table sampling on a sub query without splits is meaningless
                    return nodeSplits;
                default:
                    throw new UnsupportedOperationException("Sampling is not supported for type " + node.getSampleType());
            }
        }
        @Override
        public Optional<SplitSourcevisitAggregation(AggregationNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitMarkDistinct(MarkDistinctNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitWindow(WindowNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitRowNumber(RowNumberNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitTopNRowNumber(TopNRowNumberNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitProject(ProjectNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitUnnest(UnnestNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitTopN(TopNNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitOutput(OutputNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitLimit(LimitNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitDistinctLimit(DistinctLimitNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitSort(SortNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitTableWriter(TableWriterNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitTableCommit(TableCommitNode nodeVoid context)
        {
            return node.getSource().accept(thiscontext);
        }
        @Override
        public Optional<SplitSourcevisitUnion(UnionNode nodeVoid context)
        {
            Optional<SplitSourceresult = Optional.empty();
            for (PlanNode child : node.getSources()) {
                Optional<SplitSourcesource = child.accept(thiscontext);
                if (result.isPresent() && source.isPresent()) {
                    throw new IllegalArgumentException("Multiple children are source-distributed");
                }
                if (source.isPresent()) {
                    result = source;
                }
            }
            return result;
        }
        @Override
        protected Optional<SplitSourcevisitPlan(PlanNode nodeVoid context)
        {
            throw new UnsupportedOperationException("not yet implemented: " + node.getClass().getName());
        }
    }
New to GrepCode? Check out our FAQ X