PlanNode source = planRewriter.rewrite(node.getSource(), context);

            Map<Symbol, Expression> assignments = new LinkedHashMap<>();

            for (Map.Entry<Symbol, Expression> entry : node.getOutputMap().entrySet()) {

                if (entry.getValue() instanceof QualifiedNameReference) {

                    Symbol symbol = Symbol.fromQualifiedName(((QualifiedNameReference) entry.getValue()).getName());

                    if (!symbol.equals(entry.getKey())) {

                        map(entry.getKey(), symbol);

        @Override

        public PlanNode rewriteProject(ProjectNode node, Expression inheritedPredicate, PlanRewriter<Expression> planRewriter)

        {

            return planRewriter.defaultRewrite(node, inlinedPredicate);

        }

        {

            boolean modified = false;

            ImmutableList.Builder<PlanNode> builder = ImmutableList.builder();

            for (int i = 0; i < node.getSources().size(); i++) {

                PlanNode source = node.getSources().get(i);

                PlanNode rewrittenSource = planRewriter.rewrite(source, sourcePredicate);

                if (rewrittenSource != source) {

                    modified = true;

                }

            // See if we can rewrite outer joins in terms of a plain inner join

            node = tryNormalizeToInnerJoin(node, inheritedPredicate);

            switch (node.getType()) {

                case INNER:

                    InnerJoinPushDownResult innerJoinPushDownResult = processInnerJoin(inheritedPredicate,

                            leftEffectivePredicate,

                            rightEffectivePredicate,

                            joinPredicate,

                            node.getLeft().getOutputSymbols());

                    leftPredicate = innerJoinPushDownResult.getLeftPredicate();

                    rightPredicate = innerJoinPushDownResult.getRightPredicate();

                    postJoinPredicate = innerJoinPushDownResult.getPostJoinPredicate();

                    newJoinPredicate = innerJoinPushDownResult.getJoinPredicate();

                    break;

                case LEFT:

                    OuterJoinPushDownResult leftOuterJoinPushDownResult = processOuterJoin(inheritedPredicate,

                            leftEffectivePredicate,

                            rightEffectivePredicate,

                            joinPredicate,

                            node.getLeft().getOutputSymbols());

                    leftPredicate = leftOuterJoinPushDownResult.getOuterJoinPredicate();

                    rightPredicate = leftOuterJoinPushDownResult.getInnerJoinPredicate();

                    postJoinPredicate = leftOuterJoinPushDownResult.getPostJoinPredicate();

                    newJoinPredicate = joinPredicate; // Use the same as the original

                    break;

                case RIGHT:

                    OuterJoinPushDownResult rightOuterJoinPushDownResult = processOuterJoin(inheritedPredicate,

                            rightEffectivePredicate,

                            leftEffectivePredicate,

                            joinPredicate,

                            node.getRight().getOutputSymbols());

                    leftPredicate = rightOuterJoinPushDownResult.getInnerJoinPredicate();

                    rightPredicate = rightOuterJoinPushDownResult.getOuterJoinPredicate();

                    postJoinPredicate = rightOuterJoinPushDownResult.getPostJoinPredicate();

                    newJoinPredicate = joinPredicate; // Use the same as the original

                    break;

                default:

                    throw new UnsupportedOperationException("Unsupported join type: " + node.getType());

            }

            PlanNode leftSource = planRewriter.rewrite(node.getLeft(), leftPredicate);

            PlanNode rightSource = planRewriter.rewrite(node.getRight(), rightPredicate);

            PlanNode output = node;

                List<JoinNode.EquiJoinClause> criteria = node.getCriteria();

                // Rewrite criteria and add projections if there is a new join predicate

                    // Create identity projections for all existing symbols

                    ImmutableMap.Builder<Symbol, Expression> leftProjections = ImmutableMap.builder();

                    leftProjections.putAll(IterableTransformer.<Symbol>on(node.getLeft().getOutputSymbols())

                            .toMap(symbolToQualifiedNameReference())

                            .map());

                    ImmutableMap.Builder<Symbol, Expression> rightProjections = ImmutableMap.builder();

                    rightProjections.putAll(IterableTransformer.<Symbol>on(node.getRight().getOutputSymbols())

                            .toMap(symbolToQualifiedNameReference())

                            .map());

                    // HACK! we don't support cross joins right now, so put in a simple fake join predicate instead if all of the join clauses got simplified out

                    // TODO: remove this code when cross join support is added

                    Iterable<Expression> simplifiedJoinConjuncts = transform(extractConjuncts(newJoinPredicate), simplifyExpressions());

                    simplifiedJoinConjuncts = filter(simplifiedJoinConjuncts, not(Predicates.<Expression>equalTo(BooleanLiteral.TRUE_LITERAL)));

                    if (Iterables.isEmpty(simplifiedJoinConjuncts)) {

                        simplifiedJoinConjuncts = ImmutableList.<Expression>of(new ComparisonExpression(ComparisonExpression.Type.EQUAL, new LongLiteral("0"), new LongLiteral("0")));

                    }

                    // Create new projections for the new join clauses

                    ImmutableList.Builder<JoinNode.EquiJoinClause> builder = ImmutableList.builder();

                    for (Expression conjunct : simplifiedJoinConjuncts) {

                        checkState(joinEqualityExpression(node.getLeft().getOutputSymbols()).apply(conjunct), "Expected join predicate to be a valid join equality");

                        ComparisonExpression equality = (ComparisonExpression) conjunct;

                        boolean alignedComparison = Iterables.all(DependencyExtractor.extractUnique(equality.getLeft()), in(node.getLeft().getOutputSymbols()));

                        Symbol leftSymbol = symbolAllocator.newSymbol(leftExpression, extractType(leftExpression));

                        leftProjections.put(leftSymbol, leftExpression);

                        Symbol rightSymbol = symbolAllocator.newSymbol(rightExpression, extractType(rightExpression));

                        rightProjections.put(rightSymbol, rightExpression);

            EqualityInference inheritedInference = createEqualityInference(inheritedPredicate);

            EqualityInference outerInference = createEqualityInference(inheritedPredicate, outerEffectivePredicate);

            EqualityInference.EqualityPartition equalityPartition = inheritedInference.generateEqualitiesPartitionedBy(in(outerSymbols));

            EqualityInference potentialNullSymbolInference = createEqualityInference(outerOnlyInheritedEqualities, outerEffectivePredicate, innerEffectivePredicate, joinPredicate);

            EqualityInference potentialNullSymbolInferenceWithoutInnerInferred = createEqualityInference(outerOnlyInheritedEqualities, outerEffectivePredicate, joinPredicate);

            // Sort through conjuncts in inheritedPredicate that were not used for inference

            for (Expression conjunct : EqualityInference.nonInferrableConjuncts(inheritedPredicate)) {

                if (outerRewritten != null) {

                    outerPushdownConjuncts.add(outerRewritten);

                    // A conjunct can only be pushed down into an inner side if it can be rewritten in terms of the outer side

                    if (innerRewritten != null) {

                        innerPushdownConjuncts.add(innerRewritten);

                    }

                }

                else {

                    postJoinConjuncts.add(conjunct);

                }

            }

            // See if we can push down any outer or join predicates to the inner side

            for (Expression conjunct : EqualityInference.nonInferrableConjuncts(and(outerEffectivePredicate, joinPredicate))) {

                if (rewritten != null) {

                    innerPushdownConjuncts.add(rewritten);

                }

            }

            EqualityInference allInferenceWithoutRightInferred = createEqualityInference(inheritedPredicate, leftEffectivePredicate, joinPredicate);

            // Sort through conjuncts in inheritedPredicate that were not used for inference

            for (Expression conjunct : EqualityInference.nonInferrableConjuncts(inheritedPredicate)) {

                if (leftRewrittenConjunct != null) {

                    leftPushDownConjuncts.add(leftRewrittenConjunct);

                }

                if (rightRewrittenConjunct != null) {

                    rightPushDownConjuncts.add(rightRewrittenConjunct);

                }

                // Drop predicate after join only if unable to push down to either side

                if (leftRewrittenConjunct == null && rightRewrittenConjunct == null) {

                    joinConjuncts.add(conjunct);

                }

            }

            // See if we can push the right effective predicate to the left side

            for (Expression conjunct : EqualityInference.nonInferrableConjuncts(rightEffectivePredicate)) {

                if (rewritten != null) {

                    leftPushDownConjuncts.add(rewritten);

                }

            }

            // See if we can push the left effective predicate to the right side

            for (Expression conjunct : EqualityInference.nonInferrableConjuncts(leftEffectivePredicate)) {

                if (rewritten != null) {

                    rightPushDownConjuncts.add(rewritten);

                }

            }

            // See if we can push any parts of the join predicates to either side

            for (Expression conjunct : EqualityInference.nonInferrableConjuncts(joinPredicate)) {

                if (leftRewritten != null) {

                    leftPushDownConjuncts.add(leftRewritten);

                }

                if (rightRewritten != null) {

                    rightPushDownConjuncts.add(rightRewritten);

                }

                if (leftRewritten == null && rightRewritten == null) {

        @Override

        public PlanNode rewriteSemiJoin(SemiJoinNode node, Expression inheritedPredicate, PlanRewriter<Expression> planRewriter)

        {

            List<Expression> sourceConjuncts = new ArrayList<>();

            List<Expression> filteringSourceConjuncts = new ArrayList<>();

            List<Expression> postJoinConjuncts = new ArrayList<>();

            // TODO: see if there are predicates that can be inferred from the semi join output

            // Push inherited and source predicates to filtering source via a contrived join predicate (but needs to avoid touching NULL values in the filtering source)

            EqualityInference joinInference = createEqualityInference(inheritedPredicate, sourceEffectivePredicate, joinPredicate);

            for (Expression conjunct : Iterables.concat(EqualityInference.nonInferrableConjuncts(inheritedPredicate), EqualityInference.nonInferrableConjuncts(sourceEffectivePredicate))) {

                if (rewrittenConjunct != null && DeterminismEvaluator.isDeterministic(rewrittenConjunct)) {

                    // Alter conjunct to include an OR filteringSourceJoinSymbol IS NULL disjunct

                    filteringSourceConjuncts.add(rewrittenConjunctOrNull);

                }

            }

            EqualityInference.EqualityPartition joinInferenceEqualityPartition = joinInference.generateEqualitiesPartitionedBy(equalTo(node.getFilteringSourceJoinSymbol()));

            filteringSourceConjuncts.addAll(ImmutableList.copyOf(transform(joinInferenceEqualityPartition.getScopeEqualities(),

                    expressionOrNullSymbols(equalTo(node.getFilteringSourceJoinSymbol())))));

            // Push inheritedPredicates down to the source if they don't involve the semi join output

            EqualityInference inheritedInference = createEqualityInference(inheritedPredicate);

            for (Expression conjunct : EqualityInference.nonInferrableConjuncts(inheritedPredicate)) {

                // Since each source row is reflected exactly once in the output, ok to push non-deterministic predicates down

                if (rewrittenConjunct != null) {

                    sourceConjuncts.add(rewrittenConjunct);

                }

                else {

            inheritedPredicate = stripNonDeterministicConjuncts(inheritedPredicate);

            // Sort non-equality predicates by those that can be pushed down and those that cannot

            for (Expression conjunct : EqualityInference.nonInferrableConjuncts(inheritedPredicate)) {

                if (rewrittenConjunct != null) {

                    pushdownConjuncts.add(rewrittenConjunct);

                }

                else {

                    postAggregationConjuncts.add(conjunct);

        @Override

        public PlanNode rewriteTableScan(TableScanNode node, Expression inheritedPredicate, PlanRewriter<Expression> planRewriter)

        {

            DomainTranslator.ExtractionResult extractionResult = DomainTranslator.fromPredicate(inheritedPredicate, symbolAllocator.getTypes(), node.getAssignments());

            TupleDomain tupleDomain = extractionResult.getTupleDomain();

            if (node.getGeneratedPartitions().isPresent()) {

                // Add back in the TupleDomain that was used to generate the previous set of Partitions if present

                // And just for kicks, throw in the domain summary too (as that can only help prune down the ranges)

                // The domains should never widen between each pass.

                tupleDomain = tupleDomain.intersect(node.getGeneratedPartitions().get().getTupleDomainInput()).intersect(node.getPartitionsDomainSummary());

            }

            Stopwatch partitionTimer = Stopwatch.createStarted();

            PartitionResult matchingPartitions = splitManager.getPartitions(node.getTable(), Optional.of(tupleDomain));

            List<Partition> partitions = matchingPartitions.getPartitions();

            TupleDomain undeterminedTupleDomain = matchingPartitions.getUndeterminedTupleDomain();

            log.debug("Partition retrieval, table %s (%d partitions): %dms", node.getTable(), partitions.size(), partitionTimer.elapsed(TimeUnit.MILLISECONDS));

            // Construct the post scan predicate. Add the unevaluated TupleDomain back first since those are generally cheaper to evaluate than anything we can't extract

            // Do some early partition pruning

            partitions = ImmutableList.copyOf(filter(partitions, not(shouldPrunePartition(postScanPredicate, node.getAssignments()))));

            GeneratedPartitions generatedPartitions = new GeneratedPartitions(tupleDomain, partitions);

            PlanNode output = node;

            if (!node.getGeneratedPartitions().equals(Optional.of(generatedPartitions))) {

                // Only overwrite the originalConstraint if it was previously null

                output = new TableScanNode(node.getId(), node.getTable(), node.getOutputSymbols(), node.getAssignments(), originalConstraint, Optional.of(generatedPartitions));

            }

            if (!postScanPredicate.equals(BooleanLiteral.TRUE_LITERAL)) {

                output = new FilterNode(idAllocator.getNextId(), output, postScanPredicate);

            }

        @Override

        protected Object visitSearchedCaseExpression(SearchedCaseExpression node, Object context)

        {

            for (WhenClause whenClause : node.getWhenClauses()) {

                Object value = process(whenClause.getOperand(), context);

                if (value instanceof Expression) {

                    // TODO: optimize this case

                    return node;