// 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.

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

        return pullExpressionThroughSymbols(partitionPredicate, node.getOutputSymbols());

    }

    @Override

    public Expression visitUnion(UnionNode node, Void context)

    {

        // Rewrite in terms of output symbols

        Set<Expression> conjuncts = ImmutableSet.copyOf(extractConjuncts(firstOutputPredicate));

        // Find the intersection of all predicates

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

            // Rewrite in terms of output symbols

            // TODO: use a more precise way to determine overlapping conjuncts (e.g. commutative predicates)

            conjuncts = Sets.intersection(conjuncts, ImmutableSet.copyOf(extractConjuncts(outputPredicate)));

        }

    @Override

    public Expression visitJoin(JoinNode node, Void context)

    {

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

        for (JoinNode.EquiJoinClause clause : node.getCriteria()) {

            joinConjuncts.add(new ComparisonExpression(ComparisonExpression.Type.EQUAL,

                    new QualifiedNameReference(clause.getLeft().toQualifiedName()),

        EqualityInference equalityInference = createEqualityInference(expression);

        ImmutableList.Builder<Expression> effectiveConjuncts = ImmutableList.builder();

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

            if (rewritten != null) {

                effectiveConjuncts.add(rewritten);

            }

        }

            List<String> columns = ((JoinUsing) criteria).getColumns();

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

            for (String column : columns) {

                ExpressionAnalysis leftExpressionAnalysis = Analyzer.analyzeExpression(session, metadata, left, analysis, context, leftExpression);

                ExpressionAnalysis rightExpressionAnalysis = Analyzer.analyzeExpression(session, metadata, right, analysis, context, rightExpression);

                checkState(leftExpressionAnalysis.getSubqueryInPredicates().isEmpty(), "INVARIANT");

                checkState(rightExpressionAnalysis.getSubqueryInPredicates().isEmpty(), "INVARIANT");

                builder.add(new EquiJoinClause(leftExpression, rightExpression));

            }

            analysis.setEquijoinCriteria(node, builder.build());

        }

        else if (criteria instanceof JoinOn) {

            // ensure all names can be resolved, types match, etc (we don't need to record resolved names, subexpression types, etc. because

            // we do it further down when after we determine which subexpressions apply to left vs right tuple)

            ExpressionAnalyzer analyzer = new ExpressionAnalyzer(analysis, session, metadata);

            analyzer.analyze(expression, output, context);

            Analyzer.verifyNoAggregatesOrWindowFunctions(metadata, expression, "JOIN");

            Object optimizedExpression = ExpressionInterpreter.expressionOptimizer(expression, metadata, session).optimize(NoOpSymbolResolver.INSTANCE);

            if (!(optimizedExpression instanceof Expression) && optimizedExpression instanceof Boolean) {

                // If the JoinOn clause evaluates to a boolean expression, simulate a cross join by adding the relevant redundant expression

                if (optimizedExpression.equals(Boolean.TRUE)) {

                    optimizedExpression = new ComparisonExpression(ComparisonExpression.Type.EQUAL, new LongLiteral("0"), new LongLiteral("0"));

                }

                else {

                    optimizedExpression = new ComparisonExpression(ComparisonExpression.Type.EQUAL, new LongLiteral("0"), new LongLiteral("1"));

                }

            }

            if (!(optimizedExpression instanceof Expression)) {

                throw new SemanticException(TYPE_MISMATCH, node, "Join clause must be a boolean expression");

            }

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

            for (Expression conjunct : ExpressionUtils.extractConjuncts((Expression) optimizedExpression)) {

                if (!(conjunct instanceof ComparisonExpression)) {

                    throw new SemanticException(NOT_SUPPORTED, node, "Non-equi joins not supported: %s", conjunct);

                }

                ComparisonExpression comparison = (ComparisonExpression) conjunct;

                if (comparison.getType() != ComparisonExpression.Type.EQUAL) {

                    throw new SemanticException(NOT_SUPPORTED, node, "Non-equi joins not supported: %s", conjunct);

                }

                Set<QualifiedName> firstDependencies = DependencyExtractor.extract(comparison.getLeft());

                Set<QualifiedName> secondDependencies = DependencyExtractor.extract(comparison.getRight());

                if (Iterables.all(firstDependencies, left.canResolvePredicate()) && Iterables.all(secondDependencies, right.canResolvePredicate())) {

                    leftExpression = comparison.getLeft();

                    rightExpression = comparison.getRight();

                }

                else if (Iterables.all(firstDependencies, right.canResolvePredicate()) && Iterables.all(secondDependencies, left.canResolvePredicate())) {

    private void analyzeHaving(QuerySpecification node, TupleDescriptor tupleDescriptor, AnalysisContext context)

    {

        if (node.getHaving().isPresent()) {

            ExpressionAnalysis expressionAnalysis = Analyzer.analyzeExpression(session, metadata, tupleDescriptor, analysis, context, predicate);

            analysis.addInPredicates(node, expressionAnalysis.getSubqueryInPredicates());

            if (expressionAnalysis.getType() != Type.BOOLEAN && expressionAnalysis.getType() != Type.NULL) {

            }

            Multimap<QualifiedName, Expression> byAlias = byAliasBuilder.build();

            for (SortItem item : items) {

                FieldOrExpression orderByExpression = null;

                if (expression instanceof QualifiedNameReference && !((QualifiedNameReference) expression).getName().getPrefix().isPresent()) {

                    // if this is a simple name reference, try to resolve against output columns

    private void analyzeWhere(QuerySpecification node, TupleDescriptor tupleDescriptor, AnalysisContext context)

    {

        if (node.getWhere().isPresent()) {

            Analyzer.verifyNoAggregatesOrWindowFunctions(metadata, predicate, "WHERE");

            ExpressionAnalysis expressionAnalysis = Analyzer.analyzeExpression(session, metadata, tupleDescriptor, analysis, context, predicate);

            analysis.addInPredicates(node, expressionAnalysis.getSubqueryInPredicates());

        public PhysicalOperation visitFilter(FilterNode node, LocalExecutionPlanContext context)

        {

            PlanNode sourceNode = node.getSource();

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

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

                Symbol symbol = node.getOutputSymbols().get(i);

                projectionExpressions.add(new QualifiedNameReference(symbol.toQualifiedName()));

        @Override

        public PhysicalOperation visitProject(ProjectNode node, LocalExecutionPlanContext context)

        {

            PlanNode sourceNode;

            if (node.getSource() instanceof FilterNode) {

                FilterNode filterNode = (FilterNode) node.getSource();

                sourceNode = filterNode.getSource();

                filterExpression = filterNode.getPredicate();

            }