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 java.util.Map;
 import java.util.Set;
 
 import static com.facebook.presto.sql.ExpressionUtils.combineConjuncts;
 import static com.facebook.presto.sql.ExpressionUtils.expressionOrNullSymbols;
 import static com.facebook.presto.sql.ExpressionUtils.extractConjuncts;
 import static com.facebook.presto.sql.ExpressionUtils.stripNonDeterministicConjuncts;
 import static com.facebook.presto.sql.planner.EqualityInference.createEqualityInference;
 import static com.google.common.base.Predicates.in;
 import static com.google.common.base.Predicates.not;
 import static com.google.common.collect.Iterables.transform;

Computes the effective predicate at the top of the specified PlanNode

Note: non-deterministic predicates can not be pulled up (so they will be ignored)

 
         extends PlanVisitor<VoidExpression>
 {
     public static Expression extract(PlanNode nodeMap<SymbolTypesymbolTypes)
     {
         return node.accept(new EffectivePredicateExtractor(symbolTypes), null);
     }
 
     private final Map<SymbolTypesymbolTypes;
 
     public EffectivePredicateExtractor(Map<SymbolTypesymbolTypes)
     {
         this. = symbolTypes;
     }
 
     @Override
     protected Expression visitPlan(PlanNode nodeVoid context)
     {
         return .;
     }
 
     @Override
     public Expression visitAggregation(AggregationNode nodeVoid context)
     {
         Expression underlyingPredicate = node.getSource().accept(thiscontext);
 
         return pullExpressionThroughSymbols(underlyingPredicatenode.getGroupBy());
     }
 
     @Override
     public Expression visitFilter(FilterNode nodeVoid context)
    {
        Expression underlyingPredicate = node.getSource().accept(thiscontext);
        Expression predicate = node.getPredicate();
        // Remove non-deterministic conjuncts
        predicate = stripNonDeterministicConjuncts(predicate);
        return combineConjuncts(predicateunderlyingPredicate);
    }
    private static Predicate<Map.Entry<Symbol, ? extends Expression>> symbolMatchesExpression()
    {
        return entry -> entry.getValue().equals(new QualifiedNameReference(entry.getKey().toQualifiedName()));
    }
    private static Function<Map.Entry<Symbol, ? extends Expression>, ExpressionentryToEquality()
    {
        return entry -> {
            QualifiedNameReference reference = new QualifiedNameReference(entry.getKey().toQualifiedName());
            Expression expression = entry.getValue();
            // TODO: switch this to 'IS NOT DISTINCT FROM' syntax when EqualityInference properly supports it
            return new ComparisonExpression(..referenceexpression);
        };
    }
    @Override
    public Expression visitProject(ProjectNode nodeVoid context)
    {
        // TODO: add simple algebraic solver for projection translation (right now only considers identity projections)
        Expression underlyingPredicate = node.getSource().accept(thiscontext);
        Iterable<ExpressionprojectionEqualities = FluentIterable.from(node.getAssignments().entrySet())
                .filter(not(symbolMatchesExpression()))
                .transform(entryToEquality());
                        ImmutableList.<Expression>builder()
                                .addAll(projectionEqualities)
                                .add(underlyingPredicate)
                                .build()),
                node.getOutputSymbols());
    }
    @Override
    public Expression visitTopN(TopNNode nodeVoid context)
    {
        return node.getSource().accept(thiscontext);
    }
    @Override
    public Expression visitLimit(LimitNode nodeVoid context)
    {
        return node.getSource().accept(thiscontext);
    }
    @Override
    public Expression visitDistinctLimit(DistinctLimitNode nodeVoid context)
    {
        return node.getSource().accept(thiscontext);
    }
    @Override
    public Expression visitTableScan(TableScanNode nodeVoid context)
    {
        if (!node.getGeneratedPartitions().isPresent()) {
            return .;
        }
        // The effective predicate can be computed from the intersection of the aggregate partition TupleDomain summary (generated from Partitions)
        // and the TupleDomain that was initially used to generate those Partitions. We do this because we need to select the more restrictive of the two.
        // Note: the TupleDomain used to generate the partitions may contain columns/predicates that are unknown to the partition TupleDomain summary,
        // but those are guaranteed to be part of a FilterNode directly above this table scan, so it's ok to include.
        // A TupleDomain that has too many disjunctions will produce an Expression that will be very expensive to evaluate at runtime.
        // For the time being, we will just summarize the TupleDomain by the span over each of its columns (which is ok since we only need to generate
        // an effective predicate here).
        // In the future, we can do further optimizations here that will simplify the TupleDomain, but still improve the specificity compared to just a simple span (e.g. range clustering).
        tupleDomain = spanTupleDomain(tupleDomain);
        Expression partitionPredicate = DomainTranslator.toPredicate(tupleDomain, ImmutableBiMap.copyOf(node.getAssignments()).inverse(), );
        return pullExpressionThroughSymbols(partitionPredicatenode.getOutputSymbols());
    }
    private static TupleDomain<ColumnHandlespanTupleDomain(TupleDomain<ColumnHandletupleDomain)
    {
        if (tupleDomain.isNone()) {
            return tupleDomain;
        }
        // Retain nullability, but collapse each SortedRangeSet into a single span
        Map<ColumnHandleDomainspannedDomains = Maps.transformValues(tupleDomain.getDomains(), domain -> Domain.create(getSortedRangeSpan(domain.getRanges()), domain.isNullAllowed()));
        return TupleDomain.withColumnDomains(spannedDomains);
    }
    private static SortedRangeSet getSortedRangeSpan(SortedRangeSet rangeSet)
    {
        return rangeSet.isNone() ? SortedRangeSet.none(rangeSet.getType()) : SortedRangeSet.of(rangeSet.getSpan());
    }
    @Override
    public Expression visitSort(SortNode nodeVoid context)
    {
        return node.getSource().accept(thiscontext);
    }
    @Override
    public Expression visitWindow(WindowNode nodeVoid context)
    {
        return node.getSource().accept(thiscontext);
    }
    @Override
    public Expression visitUnion(UnionNode nodeVoid context)
    {
        // Find the predicates that can be pulled up from each source
        List<Set<Expression>> sourceOutputConjuncts = new ArrayList<>();
        for (int i = 0; i < node.getSources().size(); i++) {
            Expression underlyingPredicate = node.getSources().get(i).accept(thiscontext);
            Iterable<Expressionequalities = FluentIterable.from(node.outputSymbolMap(i).entries())
                    .filter(not(symbolMatchesExpression()))
                    .transform(entryToEquality());
            sourceOutputConjuncts.add(ImmutableSet.copyOf(extractConjuncts(pullExpressionThroughSymbols(combineConjuncts(
                            ImmutableList.<Expression>builder()
                                    .addAll(equalities)
                                    .add(underlyingPredicate)
                                    .build()),
                    node.getOutputSymbols()))));
        }
        // Find the intersection of predicates across all sources
        // TODO: use a more precise way to determine overlapping conjuncts (e.g. commutative predicates)
        Iterator<Set<Expression>> iterator = sourceOutputConjuncts.iterator();
        Set<ExpressionpotentialOutputConjuncts = iterator.next();
        while (iterator.hasNext()) {
            potentialOutputConjuncts = Sets.intersection(potentialOutputConjunctsiterator.next());
        }
        return combineConjuncts(potentialOutputConjuncts);
    }
    @Override
    public Expression visitJoin(JoinNode nodeVoid context)
    {
        Expression leftPredicate = node.getLeft().accept(thiscontext);
        Expression rightPredicate = node.getRight().accept(thiscontext);
        List<ExpressionjoinConjuncts = new ArrayList<>();
        for (JoinNode.EquiJoinClause clause : node.getCriteria()) {
            joinConjuncts.add(new ComparisonExpression(..,
                    new QualifiedNameReference(clause.getLeft().toQualifiedName()),
                    new QualifiedNameReference(clause.getRight().toQualifiedName())));
        }
        switch (node.getType()) {
            case :
            case :
                return combineConjuncts(ImmutableList.<Expression>builder()
                        .add(leftPredicate)
                        .add(rightPredicate)
                        .addAll(joinConjuncts)
                        .build());
            case :
                return combineConjuncts(ImmutableList.<Expression>builder()
                        .add(leftPredicate)
                        .addAll(transform(extractConjuncts(rightPredicate), expressionOrNullSymbols(in(node.getRight().getOutputSymbols()))))
                        .addAll(transform(joinConjunctsexpressionOrNullSymbols(in(node.getRight().getOutputSymbols()))))
                        .build());
            case :
                return combineConjuncts(ImmutableList.<Expression>builder()
                        .add(rightPredicate)
                        .addAll(transform(extractConjuncts(leftPredicate), expressionOrNullSymbols(in(node.getLeft().getOutputSymbols()))))
                        .addAll(transform(joinConjunctsexpressionOrNullSymbols(in(node.getLeft().getOutputSymbols()))))
                        .build());
            default:
                throw new UnsupportedOperationException("Unknown join type: " + node.getType());
        }
    }
    @Override
    public Expression visitSemiJoin(SemiJoinNode nodeVoid context)
    {
        // Filtering source does not change the effective predicate over the output symbols
        return node.getSource().accept(thiscontext);
    }
    private static Expression pullExpressionThroughSymbols(Expression expressionCollection<Symbolsymbols)
    {
        EqualityInference equalityInference = createEqualityInference(expression);
        ImmutableList.Builder<ExpressioneffectiveConjuncts = ImmutableList.builder();
        for (Expression conjunct : EqualityInference.nonInferrableConjuncts(expression)) {
            if (DeterminismEvaluator.isDeterministic(conjunct)) {
                Expression rewritten = equalityInference.rewriteExpression(conjunctin(symbols));
                if (rewritten != null) {
                    effectiveConjuncts.add(rewritten);
                }
            }
        }
        effectiveConjuncts.addAll(equalityInference.generateEqualitiesPartitionedBy(in(symbols)).getScopeEqualities());
        return combineConjuncts(effectiveConjuncts.build());
    }
New to GrepCode? Check out our FAQ X