github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/sql/opt/norm/rules/inline.opt

# =============================================================================
# inline.opt contains normalization patterns that replace a variable reference
# with the expression to which that variable is bound. For example:
#
#   SELECT x2+1 FROM (SELECT x+1 AS x2 FROM a)
#
# becomes:
#
#   SELECT (x+1)+1 FROM a
#
# Inlining variables can result in the simplification or even complete
# elimination of operators, or at least in the ability to more freely reorder
# them within the larger relational expression tree. This allows pushing filters
# further down the tree, as well as with pulling them up in the decorrelation
# case.
# =============================================================================

# InlineConstVar inlines variables which are restricted to be constant, as in
#   SELECT * FROM foo WHERE a = 4 AND a IN (1, 2, 3, 4).
# =>
#   SELECT * FROM foo WHERE a = 4 AND 4 IN (1, 2, 3, 4).
# Note that a single iteration of this rule might not be sufficient to inline
# all variables, in which case it will trigger itself again.
#
# This rule is high priority so that it runs before filter pushdown.
[InlineConstVar, Normalize, HighPriority]
(Select $input:* $filters:* & (CanInlineConstVar $filters))
=>
(Select $input (InlineConstVar $filters))

# InlineProjectConstants finds variable references in Projections expressions
# that refer to constant input values, and then inlines those constant values
# in place of the corresponding variable references. This sometimes allows
# further simplifications such as constant folding or Project merging.
[InlineProjectConstants, Normalize]
(Project
    $input:* &
        ^(ColsAreEmpty
            $constCols:(FindInlinableConstants $input)
        )
    $projections:[
        ...
        $item:* & (ColsIntersect (OuterCols $item) $constCols)
        ...
    ]
    $passthrough:*
)
=>
(Project
    $input
    (InlineProjectionConstants $projections $input $constCols)
    $passthrough
)

# InlineSelectConstants finds variable references in Filters expressions that
# refer to constant input values, and then inlines those constant values in
# place of the corresponding variable references. This sometimes allows further
# simplifications such as constant folding or generation of constrained scans.
[InlineSelectConstants, Normalize]
(Select
    $input:* &
        ^(ColsAreEmpty
            $constCols:(FindInlinableConstants $input)
        )
    $filters:[
        ...
        $item:* & (ColsIntersect (OuterCols $item) $constCols)
        ...
    ]
)
=>
(Select
    $input
    (InlineFilterConstants $filters $input $constCols)
)

# InlineJoinConstantsLeft finds variable references in a join condition that
# refers to constant values projected by the left input. It then inlines those
# constant values in place of the corresponding variable references. This
# sometimes allows further simplifications such as constant folding or filter
# pushdown.
[InlineJoinConstantsLeft, Normalize]
(Join
    $left:* &
        ^(ColsAreEmpty $constCols:(FindInlinableConstants $left))
    $right:*
    $on:[
        ...
        $item:* & (ColsIntersect (OuterCols $item) $constCols)
        ...
    ]
    $private:*
)
=>
((OpName)
    $left
    $right
    (InlineFilterConstants $on $left $constCols)
    $private
)

# InlineJoinConstantsRight finds variable references in a join condition that
# refers to constant values projected by the right input. It then inlines those
# constant values in place of the corresponding variable references. This
# sometimes allows further simplifications such as constant folding or filter
# pushdown.
[InlineJoinConstantsRight, Normalize]
(Join
    $left:*
    $right:* &
        ^(ColsAreEmpty
            $constCols:(FindInlinableConstants $right)
        )
    $on:[
        ...
        $item:* & (ColsIntersect (OuterCols $item) $constCols)
        ...
    ]
    $private:*
)
=>
((OpName)
    $left
    $right
    (InlineFilterConstants $on $right $constCols)
    $private
)

# PushSelectIntoInlinableProject pushes the Select operator into a Project, even
# though the filter references it. This is made possible by inlining the
# references to projected columns so that the Select becomes independent of the
# Project, and therefore can be reordered. This normalization is important for
# enabling Any filter conditions to be pushed down into scans.
#
# This rule is low priority so that it runs after the PushSelectIntoProject
# and MergeProjectProject rules, since those rules are cheaper to match and
# replace.
#
# Example:
#   SELECT * FROM (SELECT x+1 AS x2 FROM xy) WHERE x2=10
#   =>
#   SELECT x+1 AS x2 FROM (SELECT * FROM xy WHERE (x+1)=10)
#
[PushSelectIntoInlinableProject, Normalize, LowPriority]
(Select
    (Project
        $input:*
        $projections:* & (CanInlineProjections $projections)
        $passthrough:*
    )
    $filters:* & ^(FilterHasCorrelatedSubquery $filters)
)
=>
(Project
    (Select $input (InlineSelectProject $filters $projections))
    $projections
    $passthrough
)

# InlineProjectInProject folds an inner Project operator into an outer Project
# that references each inner synthesized column no more than one time. If there
# are no duplicate references, then there's no benefit to keeping the multiple
# nested projections. This rule simplifies the relational expression tree and
# makes it more likely that other normalization rules will match.
#
# This rule is low priority so that it runs after the MergeProjects rule, since
# that rule is cheaper to match and replace.
#
# Example:
#   SELECT x2*2 FROM (SELECT x+1 AS x2 FROM xy)
#   =>
#   SELECT (x+1)*2 FROM xy
#
[InlineProjectInProject, Normalize, LowPriority]
(Project
    $input:(Project * $innerProjections:*)
    $projections:*
    $passthrough:* &
        ^(HasDuplicateRefs
            $projections
            $passthrough
            (ProjectionCols $innerProjections)
        )
)
=>
(InlineProjectProject $input $projections $passthrough)