opt

const (
	UnknownOp Operator = iota

	// AggDistinct is used as a modifier that wraps an aggregate function. It causes
	// the respective aggregation to only process each distinct value once.
	AggDistinctOp

	// AggFilter is used as a modifier that wraps an aggregate function (or an
	// AggDistinct operator that wraps an aggregate function). It causes only rows
	// for which the filter expression is true to be processed. AggFilter should
	// always occur on top of AggDistinct if they are both present.
	AggFilterOp

	// Aggregations is a set of AggregationsItem expressions that specify the
	// ColumnIDs and aggregation expression for output columns projected by a
	// containing grouping operator (GroupBy, ScalarGroupBy, or DistinctOn). It is
	// legal for the set to be empty. See the AggregationsItem header for more
	// details.
	AggregationsOp

	// AggregationsItem encapsulates the information for constructing an aggregate
	// output column, including its ColumnID and the aggregate expression that
	// produces its value. In addition, the AggregationsItem caches a set of scalar
	// properties that are lazily calculated by traversing the Agg scalar expression.
	// This allows the properties for the aggregate expression to be calculated once
	// and then repeatedly reused.
	//
	// The aggregate expression can only consist of aggregate functions, variable
	// references, and modifiers like AggDistinct. Examples of valid expressions:
	//
	//   (Min (Variable 1))
	//   (Count (AggDistinct (Variable 1)))
	//
	// More complex arguments must be formulated using a Project operator as input to
	// the grouping operator.
	AggregationsItemOp

	// AlterRangeRelocate represents an `ALTER RANGE .. RELOCATE ..` statement.
	AlterRangeRelocateOp

	AlterRangeRelocatePrivateOp

	// AlterTableRelocate represents an `ALTER TABLE/INDEX .. SPLIT AT ..` statement.
	AlterTableRelocateOp

	AlterTableRelocatePrivateOp

	// AlterTableSplit represents an `ALTER TABLE/INDEX .. SPLIT AT ..` statement.
	AlterTableSplitOp

	AlterTableSplitPrivateOp

	// AlterTableUnsplit represents an `ALTER TABLE/INDEX .. UNSPLIT AT ..`
	// statement.
	AlterTableUnsplitOp

	// AlterTableUnsplit represents an `ALTER TABLE/INDEX .. UNSPLIT ALL` statement.
	AlterTableUnsplitAllOp

	// And is the boolean conjunction operator that evaluates to true only if both of
	// its conditions evaluate to true.
	AndOp

	AntiJoinOp

	AntiJoinApplyOp

	// Any is a SQL operator that applies a comparison to every row of an input
	// subquery and returns true if any of the comparisons are true, else returns
	// null if any of the comparisons are null, else returns false. The following
	// transformations map from various SQL operators into the Any operator:
	//
	//   <scalar> IN (<subquery>)
	//   ==> (Any <subquery> <scalar> EqOp)
	//
	//   <scalar> NOT IN (<subquery>)
	//   ==> (Not (Any <subquery> <scalar> EqOp))
	//
	//   <scalar> <cmp> {SOME|ANY}(<subquery>)
	//   ==> (Any <subquery> <scalar> <cmp>)
	//
	//   <scalar> <cmp> ALL(<subquery>)
	//   ==> (Not (Any <subquery> <scalar> <negated-cmp>))
	//
	// Any expects the input subquery to return a single column of any data type. The
	// scalar value is compared with that column using the specified comparison
	// operator.
	AnyOp

	// AnyNotNullAgg returns any non-NULL value it receives, with no other guarantees.
	// If it does not receive any values, it returns NULL.
	//
	// AnyNotNullAgg is not part of SQL, but it's used internally to rewrite
	// correlated subqueries into an efficient and convenient form.
	AnyNotNullAggOp

	// AnyScalar is the form of ANY which refers to an ANY operation on a
	// tuple or array, as opposed to Any which operates on a subquery.
	AnyScalarOp

	// Array is an ARRAY literal of the form ARRAY[<expr1>, <expr2>, ..., <exprN>].
	ArrayOp

	ArrayAggOp

	// ArrayFlatten is an ARRAY(<subquery>) expression. ArrayFlatten takes as input
	// a subquery which returns a single column and constructs a scalar array as the
	// output. Any NULLs are included in the results, and if the subquery has an
	// ORDER BY clause that ordering will be respected by the resulting array.
	ArrayFlattenOp

	// AssignmentCast is similar to CastExpr, but is performed in the context of an
	// INSERT, UPDATE, or UPSERT to match the type of a mutation value to the type of
	// the target column. An expression separate from CastExpr is required because it
	// behaves slightly differently than an explicit cast. For example, while an
	// explicit cast will truncate a value to fit the width of a type, an assignment
	// cast will error instead if the value does not fit the type. See
	// tree.CastContext for more details.
	//
	// An assignment cast is represented as a distinct expression within the
	// optimizer, but is built into a crdb_internal.assignment_cast function call in
	// execbuilder.
	AssignmentCastOp

	AvgOp

	// BBoxCovers is the ~ operator when used with geometry or bounding box
	// operands. It maps to tree.RegMatch.
	BBoxCoversOp

	// BBoxIntersects is the && operator when used with geometry or bounding box
	// operands. It maps to tree.Overlaps.
	BBoxIntersectsOp

	BitAndAggOp

	BitOrAggOp

	BitandOp

	BitorOp

	BitxorOp

	BoolAndOp

	BoolOrOp

	CancelPrivateOp

	// CancelQueries represents a `CANCEL QUERIES` statement.
	CancelQueriesOp

	// CancelSessions represents a `CANCEL SESSIONS` statement.
	CancelSessionsOp

	// Case is a CASE statement of the form:
	//
	//   CASE [ <Input> ]
	//       WHEN <condval1> THEN <expr1>
	//     [ WHEN <condval2> THEN <expr2> ] ...
	//     [ ELSE <expr> ]
	//   END
	//
	// The Case operator evaluates <Input> (if not provided, Input is set to True),
	// then picks the WHEN branch where <condval> is equal to <Input>, then evaluates
	// and returns the corresponding THEN expression. If no WHEN branch matches, the
	// ELSE expression is evaluated and returned, if any. Otherwise, NULL is
	// returned.
	//
	// Note that the Whens list inside Case is used to represent all the WHEN
	// branches. It is of the form:
	//
	//   [(When <condval1> <expr1>),(When <condval2> <expr2>),...]
	//
	CaseOp

	// Cast converts the input expression into an expression of the target type. Note
	// that the conversion may cause truncation based on the target types' width,
	// such as in this example:
	//
	//   'hello'::VARCHAR(2)
	//
	// That expression has the effect of truncating the string to just 'he', since
	// the target data type allows a maximum of two characters. This is one example
	// of a "lossy" cast.
	CastOp

	CoalesceOp

	// Collate is an expression of the form
	//
	//     x COLLATE y
	//
	// Where x is a "string type" (meaning either a normal string or a collated string),
	// and y is a locale. It evaluates to the string collated to the given locale.
	CollateOp

	// ColumnAccess is a scalar expression that returns a column from the given
	// input expression (which is assumed to be of type Tuple). Idx is the ordinal
	// index of the column in Input.
	ColumnAccessOp

	ConcatOp

	ConcatAggOp

	// Const is a typed scalar constant value. The Value field is a tree.Datum value
	// having any datum type that's legal in the expression's context. Do NOT call
	// ConstructConst directly; use ConstructConstVal instead.
	ConstOp

	// ConstAgg is used in the special case when the value of a column is known to be
	// constant within a grouping set; it returns that value. If there are no rows
	// in the grouping set, then ConstAgg returns NULL.
	//
	// ConstAgg is not part of SQL, but it's used internally to rewrite correlated
	// subqueries into an efficient and convenient form.
	ConstAggOp

	// ConstNotNullAgg is used in the special case when the value of a column is
	// known to be constant within a grouping set, except on some rows where it can
	// have a NULL value; it returns the non-NULL constant value. If there are no
	// rows in the grouping set, or all rows have a NULL value, then ConstNotNullAgg
	// returns NULL.
	//
	// ConstNotNullAgg is not part of SQL, but it's used internally to rewrite
	// correlated subqueries into an efficient and convenient form.
	ConstNotNullAggOp

	ContainedByOp

	ContainsOp

	// ControlJobs represents a `PAUSE/CANCEL/RESUME JOBS` statement.
	ControlJobsOp

	ControlJobsPrivateOp

	// ControlSchedules represents a `PAUSE/CANCEL/RESUME SCHEDULES` statement.
	ControlSchedulesOp

	ControlSchedulesPrivateOp

	CorrOp

	CountOp

	CountRowsOp

	CovarPopOp

	CovarSampOp

	// CreateStatistics represents a CREATE STATISTICS or ANALYZE statement.
	CreateStatisticsOp

	CreateStatisticsPrivateOp

	// CreateTable represents a CREATE TABLE statement.
	CreateTableOp

	CreateTablePrivateOp

	CreateViewOp

	CreateViewPrivateOp

	// CumeDist is the relative rank of the current row:
	// (number of rows preceding or peer with current row) / (total rows)
	CumeDistOp

	// Delete is an operator used to delete all rows that are selected by a
	// relational input expression:
	//
	//   DELETE FROM abc WHERE a>0 ORDER BY b LIMIT 10
	//
	DeleteOp

	// DenseRank is like Rank, but without gaps. Instead of 1, 1, 3, it gives 1, 1, 2.
	DenseRankOp

	// DistinctOn filters out rows that are identical on the set of grouping columns;
	// only the first row (according to an ordering) is kept for each set of possible
	// values. It is roughly equivalent with a GroupBy on the same grouping columns
	// except that it uses FirstAgg functions that ensure the value on the first row
	// is chosen (across all aggregations).
	//
	// In addition, the value on that first row must be chosen for all the grouping
	// columns as well; this is relevant in the case of equal but non-identical
	// values, like decimals. For example, if we have rows (1, 2.0) and (1.0, 2) and
	// we are grouping on these two columns, the values output can be either (1, 2.0)
	// or (1.0, 2), but not (1.0, 2.0).
	//
	// The execution of DistinctOn resembles that of Select more than that of
	// GroupBy: each row is tested against a map of what groups we have seen already,
	// and is either passed through or discarded. In particular, note that this
	// preserves the input ordering.
	//
	// The ordering in the GroupingPrivate field will be required of the input; it
	// determines which row can get "chosen" for each group of values on the grouping
	// columns. There is no restriction on the ordering; but note that grouping
	// columns are inconsequential - they can appear anywhere in the ordering and
	// they won't change the results (other than the result ordering).
	//
	// Currently when we build DistinctOn, we set all grouping columns as optional
	// cols in Ordering (but this is not required by the operator).
	//
	// TODO(radu): in the future we may want an exploration transform to try out more
	// specific interesting orderings because execution is more efficient when we can
	// rely on an ordering on the grouping columns (or a subset of them).
	//
	// DistinctOn uses an Aggregations child and the GroupingPrivate struct so that
	// it's polymorphic with GroupBy and can be used in the same rules (when
	// appropriate). In the DistinctOn case, the aggregations can be only FirstAgg or
	// ConstAgg.
	DistinctOnOp

	// Distribute enforces the physical distribution of rows returned by its input
	// expression. Currently, it is only used to re-distribute data across different
	// sets of regions in a multi-region cluster. For example, if rows are spread
	// across multiple regions, a Distribute enforcer can be used to route the rows
	// to the gateway region. See the Distribution field in the PhysicalProps struct.
	// TODO(rytaft): We should probably include the input distribution here so we can
	// accurately cost the Distribute operator. This will likely require calculating
	// "interesting distributions", similar to "interesting orderings".
	DistributeOp

	DivOp

	// EnsureDistinctOn is a variation on DistinctOn that is only used to replace a
	// Max1Row operator in a decorrelation attempt. It raises an error if any
	// distinct grouping contains more than one row. Or in other words, it "ensures"
	// that the input is distinct on the grouping columns.
	//
	// EnsureDistinctOn is used when nulls are not considered distinct for grouping
	// purposes and an error should be raised when duplicates are detected.
	//
	// Rules should only "push through" or eliminate an EnsureDistinctOn if they
	// preserve the expected error behavior. For example, it would be invalid to
	// push a Select filter into an EnsureDistinctOn, as it might eliminate rows
	// that would otherwise trigger the EnsureDistinctOn error.
	EnsureDistinctOnOp

	// EnsureUpsertDistinctOn is a variation on UpsertDistinctOn that is only used
	// with UPSERT and INSERT..ON CONFLICT statements. Like UpsertDistinctOn,
	// EnsureUpsertDistinctOn treats NULL values as not equal to one another for
	// purposes of grouping. Unlike UpsertDistinctOn, it raises an error if any
	// distinct grouping contains more than one row. Or in other words, it "ensures"
	// that the input is distinct on the grouping columns.
	//
	// EnsureUpsertDistinctOn is used when nulls are considered distinct for grouping
	// purposes and an error should be raised when duplicates are detected.
	//
	// Rules should only "push through" or eliminate an EnsureUpsertDistinctOn if
	// they preserve the expected error behavior. For example, it would be invalid to
	// push a Select filter into an EnsureUpsertDistinctOn, as it might eliminate
	// rows that would otherwise trigger the EnsureUpsertDistinctOn error.
	EnsureUpsertDistinctOnOp

	EqOp

	// Except is an operator used to perform a set difference between the Left and
	// Right input relations. The result consists only of rows in the Left relation
	// that are not present in the Right relation. Duplicate rows are discarded.
	// The SetPrivate field matches columns from the Left and Right inputs of the Except
	// with the output columns. See the comment above SetPrivate for more details.
	ExceptOp

	// ExceptAll is an operator used to perform a set difference between the Left
	// and Right input relations. The result consists only of rows in the Left
	// relation that do not have a corresponding row in the Right relation.
	// Duplicate rows are not discarded. This effectively creates a one-to-one
	// mapping between the Left and Right rows. For example:
	//   SELECT x FROM xx EXCEPT ALL SELECT y FROM yy
	//     x       y         out
	//   -----   -----      -----
	//     1       1    ->    1
	//     1       1          4
	//     1       2
	//     2       2
	//     2       3
	//     4
	//
	// The SetPrivate field matches columns from the Left and Right inputs of the
	// ExceptAll with the output columns. See the comment above SetPrivate for more
	// details.
	ExceptAllOp

	// Exists takes a relational query as its input, and evaluates to true if the
	// query returns at least one row.
	ExistsOp

	// Explain returns information about the execution plan of the "input"
	// expression.
	ExplainOp

	ExplainPrivateOp

	// Export represents an `EXPORT` statement.
	ExportOp

	ExportPrivateOp

	// FKChecks is a list of foreign key check queries, to be run after the main
	// query.
	FKChecksOp

	// FKChecksItem is a foreign key check query, to be run after the main query.
	// An execution error will be generated if the query returns any results.
	FKChecksItemOp

	FKChecksItemPrivateOp

	// FakeRel is a mock relational operator used for testing and as a dummy binding
	// relation for building cascades; its logical properties are pre-determined and
	// stored in the private. It can be used as the child of an operator for which we
	// are calculating properties or statistics.
	FakeRelOp

	FakeRelPrivateOp

	// False is the boolean false value that is equivalent to the tree.DBoolFalse
	// datum value. It is a separate operator to make matching and replacement
	// simpler and more efficient, as patterns can contain (False) expressions.
	FalseOp

	FetchTextOp

	FetchTextPathOp

	FetchValOp

	FetchValPathOp

	// Filters is a set of FiltersItem expressions that specify a set of conjuncts
	// that filter rows selected by a containing Select or Join operator. A row is
	// filtered only if all conditions evaluate to true. If the set is empty, then
	// it never filters rows. See the Select and FiltersItem headers for more
	// details.
	FiltersOp

	// FiltersItem contains a filter condition that's evaluated to determine whether
	// Select or Join rows should be filtered. In addition, the FiltersItem caches a
	// set of scalar properties that are lazily calculated by traversing the
	// Condition scalar expression. This allows the properties for the entire
	// expression subtree to be calculated once and then repeatedly reused.
	FiltersItemOp

	// FirstAgg is used only by DistinctOn; it returns the value on the first row
	// according to an ordering; if the ordering is unspecified (or partially
	// specified), it is an arbitrary ordering but it must be the same across all
	// FirstAggs in a DistinctOn.
	FirstAggOp

	// FirstValue returns Value evaluated at the first row in the row's frame.
	// TODO(justin): can this be unified with FirstAgg?
	FirstValueOp

	FloorDivOp

	FullJoinOp

	// Function invokes a builtin SQL function like CONCAT or NOW, passing the given
	// arguments. The FunctionPrivate field contains the name of the function as well
	// as pointers to its type and properties.
	FunctionOp

	FunctionPrivateOp

	GeOp

	// GroupBy computes aggregate functions over groups of input rows. Input rows
	// that are equal on the grouping columns are grouped together. The set of
	// computed aggregate functions is described by the Aggregations field (which is
	// always an Aggregations operator).
	//
	// The arguments of the aggregate functions are columns from the input
	// (i.e. Variables), possibly wrapped in aggregate modifiers like AggDistinct.
	//
	// If the set of input rows is empty, then the output of the GroupBy operator
	// will also be empty. If the grouping columns are empty, then all input rows
	// form a single group. GroupBy is used for queries with aggregate functions,
	// HAVING clauses and/or GROUP BY expressions.
	//
	// The GroupingPrivate field contains an ordering; this ordering serves a
	// dual-purpose:
	//  - if we ignore any grouping columns, the remaining columns indicate an
	//    intra-group ordering; this is useful if there is an order-dependent
	//    aggregation (like ARRAY_AGG).
	//  - any prefix containing only grouping columns is used to execute the
	//    aggregation in a streaming fashion.
	//
	// Currently, the initially built GroupBy has all grouping columns as "optional"
	// in the ordering (we call this the "canonical" variant). Subsequently, the
	// GenerateStreamingGroupBy exploration rule can add more variants, based on
	// interesting orderings.
	GroupByOp

	// GroupingPrivate is shared between the grouping-related operators: GroupBy
	// ScalarGroupBy, DistinctOn, EnsureDistinctOn, UpsertDistinctOn, and
	// EnsureUpsertDistinctOn. This allows the operators to be treated
	// polymorphically.
	GroupingPrivateOp

	GtOp

	ILikeOp

	// IfErr is roughly a runtime try-catch operator. It has different semantics
	// depending on which of its fields are set.
	//
	// If ErrCode is set, only errors which match the given error code will be
	// caught. If ErrCode is not set, all errors will be caught.
	//
	// If OrElse is not set, IfErr evaluates to true or false indicating whether an
	// error was caught.  If OrElse is set, IfErr evaluates to Cond if no error was
	// caught and to OrElse if an error was caught.
	//
	// TODO(justin): The implementation here is a hack: ErrCode and OrElse are
	// optional, so we repurpose lists as an optional field (since it's not
	// valid to use nil). If this comes up again, we might want to consider
	// adding an explicit Option type.
	IfErrOp

	InOp

	// IndexJoin represents an inner join between an input expression and a primary
	// index. It is a special case of LookupJoin where the input columns are the PK
	// columns of the table we are looking up into, and every input row results in
	// exactly one output row.
	//
	// IndexJoin operators are created from Scan operators (unlike lookup joins which
	// are created from Join operators).
	IndexJoinOp

	IndexJoinPrivateOp

	// Indirection is a subscripting expression of the form <expr>[<index>].
	// Input must be an Array type and Index must be an int. Multiple indirections
	// and slicing are not supported.
	IndirectionOp

	// InnerJoin creates a result set that combines columns from its left and right
	// inputs, based upon its "on" join predicate. Rows which do not match the
	// predicate are filtered. While expressions in the predicate can refer to
	// columns projected by either the left or right inputs, the inputs are not
	// allowed to refer to the other's projected columns.
	InnerJoinOp

	// InnerJoinApply has the same join semantics as InnerJoin. However, unlike
	// InnerJoin, it allows the right input to refer to columns projected by the
	// left input.
	InnerJoinApplyOp

	// Insert evaluates a relational input expression, and inserts values from it
	// into a target table. The input may be an arbitrarily complex expression:
	//
	//   INSERT INTO ab SELECT x, y+1 FROM xy ORDER BY y
	//
	// It can also be a simple VALUES clause:
	//
	//   INSERT INTO ab VALUES (1, 2)
	//
	// It may also return rows, which can be further composed:
	//
	//   SELECT a + b FROM [INSERT INTO ab VALUES (1, 2) RETURNING a, b]
	//
	// The Insert operator is capable of inserting values into computed columns and
	// mutation columns, which are not writable (or even visible in the case of
	// mutation columns) by SQL users.
	InsertOp

	// Intersect is an operator used to perform an intersection between the Left
	// and Right input relations. The result consists only of rows in the Left
	// relation that are also present in the Right relation. Duplicate rows are
	// discarded.
	// The SetPrivate field matches columns from the Left and Right inputs of the
	// Intersect with the output columns. See the comment above SetPrivate for more
	// details.
	// Note that Intersect is symmetric in most cases, but there are exceptions:
	// some types allow values that are equal but not identical (e.g. collated
	// strings) in which case it could be visible which side a row is coming from.
	IntersectOp

	// IntersectAll is an operator used to perform an intersection between the Left
	// and Right input relations. The result consists only of rows in the Left
	// relation that have a corresponding row in the Right relation. Duplicate rows
	// are not discarded. This effectively creates a one-to-one mapping between the
	// Left and Right rows. For example:
	//
	//   SELECT x FROM xx INTERSECT ALL SELECT y FROM yy
	//     x       y         out
	//   -----   -----      -----
	//     1       1          1
	//     1       1    ->    1
	//     1       2          2
	//     2       2          2
	//     2       3
	//     4
	//
	// The SetPrivate field matches columns from the Left and Right inputs of the
	// IntersectAll with the output columns. See the comment above SetPrivate for more
	// details.
	// Note that IntersectAll is symmetric in most cases, but there are exceptions:
	// some types allow values that are equal but not identical (e.g. collated
	// strings) in which case it could be visible which side a row is coming from.
	IntersectAllOp

	// InvertedFilter filters rows from its input result set, based on the
	// InvertedExpression predicate (which is defined in InvertedFilterPrivate).
	// Rows which do not match the filter are discarded. The input should be a
	// constrained scan of an inverted index, possibly wrapped in other operators
	// such as Select.
	InvertedFilterOp

	InvertedFilterPrivateOp

	// InvertedJoin represents a join between an input expression and an inverted
	// index. The type of join is in the InvertedJoinPrivate field.
	InvertedJoinOp

	InvertedJoinPrivateOp

	// Is maps to the IS NOT DISTINCT FROM operator which is equivalent to IS for
	// non-tuples. See IsTupleNull for the tuple-specific IS NULL operator.
	IsOp

	// IsNot is the inverse of Is. It maps to the IS DISTINCT FROM operator which is
	// equivalent to IS NOT for non-tuples. See IsTupleNotNull for the
	// tuple-specific IS NOT NULL operator.
	IsNotOp

	// IsTupleNotNull is the boolean expression with a tuple input that evaluates to
	// true if the tuple is not null and all elements in the tuple are not null.
	IsTupleNotNullOp

	// IsTupleNull is the boolean expression with a tuple input that evaluates to
	// true if the tuple is null or all elements in the tuple are null.
	IsTupleNullOp

	// JoinPrivate is shared between the various join operators including apply
	// variants, but excluding IndexJoin, LookupJoin, MergeJoin.
	JoinPrivateOp

	JsonAggOp

	JsonAllExistsOp

	JsonExistsOp

	JsonObjectAggOp

	JsonSomeExistsOp

	JsonbAggOp

	JsonbObjectAggOp

	// KVOptions is a set of KVOptionItems that specify arbitrary keys and values
	// that are used as modifiers for various statements (see tree.KVOptions). The
	// key is a constant string but the value can be a scalar expression.
	KVOptionsOp

	// KVOptionsItem is the key and value of an option (see tree.KVOption). For keys
	// that don't have values, the value is Null.
	KVOptionsItemOp

	LShiftOp

	// Lag returns Value evaluated at the row Offset rows before this one. If no
	// such row exists, returns Def.
	LagOp

	// LastValue returns Value evaluated at the last row in the row's frame.
	LastValueOp

	LeOp

	// Lead returns Value evaluated at the row Offset rows after this one. If no
	// such row exists, returns Def.
	LeadOp

	LeftJoinOp

	LeftJoinApplyOp

	LikeOp

	// Limit returns a limited subset of the results in the input relation. The limit
	// expression is a scalar value; the operator returns at most this many rows. The
	// Ordering field is a physical.OrderingChoice which indicates the row ordering
	// required from the input (the first rows with respect to this ordering are
	// returned).
	LimitOp

	// LocalityOptimizedSearch is similar to UnionAll, but it is designed to avoid
	// communicating with remote nodes (relative to the gateway region) if at all
	// possible. LocalityOptimizedSearch can be planned when a scan is known to
	// produce at most one row, but it is not known which region contains that row
	// (if any). In this case, the scan can be split in two, and the resulting scans
	// will become the children of the LocalityOptimizedSearch operator. The left
	// scan should only contain spans targeting partitions on local nodes, and the
	// right scan should contain the remaining spans. The LocalityOptimizedSearch
	// operator ensures that the right child (containing remote spans) is only
	// executed if the left child (containing local spans) does not return any rows.
	//
	// This is a useful optimization if there is locality of access in the workload,
	// such that rows tend to be accessed from the region where they are located.
	// If there is no locality of access, using LocalityOptimizedSearch could be a
	// slight pessimization, since rows residing in remote regions will be fetched
	// slightly more slowly than they would be otherwise.
	//
	// For example, suppose we have a multi-region database with regions 'us-east1',
	// 'us-west1' and 'europe-west1', and we have the following table and query,
	// issued from 'us-east1':
	//
	//   CREATE TABLE tab (
	//     k INT PRIMARY KEY,
	//     v INT
	//   ) LOCALITY REGIONAL BY ROW;
	//
	//   SELECT * FROM tab WHERE k = 10;
	//
	// Normally, this would produce the following plan:
	//
	//   scan tab
	//    └── constraint: /3/1
	//         ├── [/'europe-west1'/10 - /'europe-west1'/10]
	//         ├── [/'us-east1'/10 - /'us-east1'/10]
	//         └── [/'us-west1'/10 - /'us-west1'/10]
	//
	// but if the session setting locality_optimized_partitioned_index_scan is enabled,
	// the optimizer will produce this plan, using locality optimized search:
	//
	//   locality-optimized-search
	//    ├── scan tab
	//    │    └── constraint: /9/7: [/'us-east1'/10 - /'us-east1'/10]
	//    └── scan tab
	//         └── constraint: /14/12
	//              ├── [/'europe-west1'/10 - /'europe-west1'/10]
	//              └── [/'us-west1'/10 - /'us-west1'/10]
	//
	// As long as k = 10 is located in 'us-east1', the second plan will be much faster.
	// But if k = 10 is located in one of the other regions, the first plan would be
	// slightly faster.
	LocalityOptimizedSearchOp

	// LookupJoin represents a join between an input expression and an index. The
	// type of join is in the LookupJoinPrivate field.
	LookupJoinOp

	LookupJoinPrivateOp

	LtOp

	MaxOp

	// Max1Row enforces that its input must return at most one row. If the input
	// has more than one row, Max1Row raises an error with the specified error text.
	//
	// Max1Row is most often used as input to the Subquery operator. See the comment
	// above Subquery for more details.
	Max1RowOp

	// MemoCycleTestRel is a relational expression for testing that memo cycles are
	// detected by the optimizer and a stack overflow is prevented. A cycle in the
	// memo occurs when there is a path from a group member's children back to the
	// group member's group. MemoCycleTestRel is similar in structure to the Select
	// expression, but matches a rule, MemoCycleTestRelRule, that creates a memo
	// cycle.
	MemoCycleTestRelOp

	// MergeJoin represents a join that is executed using merge-join.
	// MergeOn is a scalar which contains the ON condition and merge-join ordering
	// information; see the MergeOn scalar operator.
	// It can be any type of join (identified in the MergeJoinPrivate field).
	MergeJoinOp

	MergeJoinPrivateOp

	MinOp

	MinusOp

	ModOp

	MultOp

	MutationPrivateOp

	NeOp

	// NormCycleTestRel is a relational operator for testing that normalization rule
	// cycles are detected by the Factory and a stack overflow is prevented. Two
	// rules for this expression, NormCycleTestRelTrueToFalse and
	// NormCycleTestRelFalseToTrue, create a normalization rule cycle. See the cycle
	// test file for tests that use this expression.
	NormCycleTestRelOp

	// Not is the boolean negation operator that evaluates to true if its input
	// evaluates to false.
	NotOp

	NotILikeOp

	NotInOp

	NotLikeOp

	NotRegIMatchOp

	NotRegMatchOp

	NotSimilarToOp

	// NthValue returns Value evaluated at the nth row in the row's frame.
	// Out-of-bounds references evaluate to NULL.
	NthValueOp

	// Ntile builds a histogram with the specified number of buckets and evaluates
	// to which bucket the row falls in.
	NtileOp

	// Null is the constant SQL null value that has "unknown value" semantics. If
	// the Typ field is not types.Unknown, then the value is known to be in the
	// domain of that type. This is important for preserving correct types in
	// replacement patterns. For example:
	//   (Plus (Function ...) (Const 1))
	//
	// If the function in that expression has a static type of Int, but then it gets
	// constant folded to (Null), then its type must remain as Int. Any other type
	// violates logical equivalence of the expression, breaking type inference and
	// possibly changing the results of execution. The solution is to tag the null
	// with the correct type:
	//   (Plus (Null (Int)) (Const 1))
	//
	// Null is its own operator rather than a Const datum in order to make matching
	// and replacement easier and more efficient, as patterns can contain (Null)
	// expressions.
	NullOp

	// Offset filters out the first Offset rows of the input relation; used in
	// conjunction with Limit.
	OffsetOp

	// OpaqueMutation is a variant of OpaqueRel for operators that cause a schema
	// change and cannot be executed following a mutation in the same transaction.
	OpaqueDDLOp

	// OpaqueMutation is a variant of OpaqueRel for operators that can mutate data as
	// part of the transaction.
	OpaqueMutationOp

	// OpaqueRel is an opaque relational operator which is planned outside of the
	// optimizer. The operator contains an opaque metadata which is passed to the
	// exec factory.
	//
	// This is used for statements that are not directly supported by the optimizer,
	// and which don't use the result of other relational expressions (in other
	// words, they are a "leaf" operator).
	//
	// OpaqueRel can produce data and can be used as a data source as part of a
	// larger enclosing query.
	OpaqueRelOp

	OpaqueRelPrivateOp

	// Or is the boolean disjunction operator that evaluates to true if either one of
	// its conditions evaluates to true.
	OrOp

	// Ordinality adds a column to each row in its input containing a unique,
	// increasing number.
	OrdinalityOp

	OrdinalityPrivateOp

	OverlapsOp

	// PercentRank is (rank - 1) / (total rows - 1).
	PercentRankOp

	// PercentileCont returns a value such that N% of values are below it
	// in a given window, interpolating values if needed. Ignores nulls in the
	// input.
	PercentileContOp

	// PercentileDisc returns a value such that N% of values are below it
	// in a given window. Ignores nulls in the input.
	PercentileDiscOp

	PlaceholderOp

	// PlaceholderScan is a special variant of Scan. It scans exactly one span of a
	// non-inverted index, and the span has the same start and end key. The values
	// for the span key are child scalar operators which are either constants or
	// placeholders. This operator evaluates the placeholders at execbuild time.
	//
	// PlaceholderScan cannot have a Constraint or InvertedConstraint.
	PlaceholderScanOp

	PlusOp

	PowOp

	// Project modifies the set of columns returned by the input result set. Columns
	// can be removed, reordered, or renamed. In addition, new columns can be
	// synthesized.
	//
	// Projections describes the synthesized columns constructed by Project, and
	// Passthrough describes the input columns that are passed through as Project
	// output columns.
	ProjectOp

	// ProjectSet represents a relational operator which zips through a list of
	// generators for every row of the input.
	//
	// As a reminder, a functional zip over generators a,b,c returns tuples of
	// values from a,b,c picked "simultaneously". NULLs are used when a generator is
	// "shorter" than another.  For example:
	//
	//    zip([1,2,3], ['a','b']) = [(1,'a'), (2,'b'), (3, null)]
	//
	// ProjectSet corresponds to a relational operator project(R, a, b, c, ...)
	// which, for each row in R, produces all the rows produced by zip(a, b, c, ...)
	// with the values of R prefixed. Formally, this performs a lateral cross join
	// of R with zip(a,b,c).
	//
	// See the Zip header for more details.
	ProjectSetOp

	// Projections is a set of ProjectionsItem expressions that specify the ColumnIDs
	// and scalar expressions for the synthesized output columns projected by a
	// containing Project operator. It is legal for the set to be empty. See the
	// Project and ProjectionsItem headers for more details.
	ProjectionsOp

	// ProjectionsItem encapsulates the information needed to synthesize an output
	// column, including its ColumnID and the scalar expression that produces its
	// value. In addition, the ProjectionsItem caches a set of scalar properties that
	// are lazily calculated by traversing the Element scalar expression. This allows
	// the properties for the entire expression subtree to be calculated once and
	// then repeatedly reused.
	//
	// The Element scalar expression cannot contain a simple VariableOp with the same
	// ColumnID as the one stored in the Col field, since that would make it a
	// pass-through column. Pass-through columns are always stored on the containing
	// Project operator instead. However, the Element field can contain a VariableOp
	// when a new ColumnID is being assigned, such as in the case of an outer column
	// reference.
	ProjectionsItemOp

	RShiftOp

	// Range contains an And expression that constrains a single variable to a
	// range. For example, the And expression might be x > 5 AND x < 10. The
	// children of the And expression can be arbitrary expressions (including nested
	// And expressions), but they must all constrain the same variable, and the
	// constraints must be tight.
	//
	// Currently, Range expressions are only created by the ConsolidateSelectFilters
	// normalization rule.
	RangeOp

	// Rank computes the position of a row relative to an ordering, with same-valued
	// rows receiving the same value.
	RankOp

	// RecursiveCTE implements the logic of a recursive CTE:
	//  * the Initial query is evaluated; the results are emitted and also saved into
	//    a "working table".
	//  * so long as the working table is not empty:
	//    - the Recursive query (which refers to the working table using a specific
	//      WithID) is evaluated; the results are emitted and also saved into a new
	//      "working table" for the next iteration.
	RecursiveCTEOp

	RecursiveCTEPrivateOp

	RegIMatchOp

	RegMatchOp

	RegressionAvgXOp

	RegressionAvgYOp

	RegressionCountOp

	RegressionInterceptOp

	RegressionR2Op

	RegressionSXXOp

	RegressionSXYOp

	RegressionSYYOp

	RegressionSlopeOp

	RightJoinOp

	// RowNumber computes the position of a row relative to an ordering, with
	// same-valued rows having ties broken arbitrarily.
	RowNumberOp

	STCollectOp

	STExtentOp

	STMakeLineOp

	STUnionOp

	// ScalarGroupBy computes aggregate functions over the complete set of input
	// rows. This is similar to GroupBy with empty grouping columns, where all input
	// rows form a single group. However, there is an important difference. If the
	// input set is empty, then the output of the ScalarGroupBy operator will have a
	// single row containing default values for each aggregate function (typically
	// null or zero, depending on the function). ScalarGroupBy always returns exactly
	// one row - either the single-group aggregates or the default aggregate values.
	//
	// ScalarGroupBy uses the GroupingPrivate struct so that it's polymorphic with
	// GroupBy and can be used in the same rules (when appropriate). In the
	// ScalarGroupBy case, the grouping column field in GroupingPrivate is always
	// empty.
	ScalarGroupByOp

	// ScalarList is a list expression that has scalar expression items of type
	// opt.ScalarExpr. opt.ScalarExpr is an external type that is defined outside of
	// Optgen. It is hard-coded in the code generator to be the item type for
	// ScalarList.
	//
	// TODO(andyk): Consider adding Optgen syntax like:
	//                define ScalarList []ScalarExpr
	ScalarListOp

	// Scan returns a result set containing every row in a table by scanning one of
	// the table's indexes according to its ordering. The ScanPrivate field
	// identifies the table and index to scan, as well as the subset of columns to
	// project from it.
	//
	// The scan can be constrained and/or have an internal row limit. A scan can be
	// executed either as a forward or as a reverse scan (except when it has a limit,
	// in which case the direction is fixed).
	ScanOp

	ScanPrivateOp

	// Select filters rows from its input result set, based on the boolean filter
	// predicate expression. Rows which do not match the filter are discarded. While
	// the Filter operand can be any boolean expression, normalization rules will
	// typically convert it to a Filters operator in order to make conjunction list
	// matching easier.
	SelectOp

	SemiJoinOp

	SemiJoinApplyOp

	// SequenceSelect represents a read from a sequence as a data source. It always returns
	// three columns, last_value, log_cnt, and is_called, with a single row. last_value is
	// the most recent value returned from the sequence and log_cnt and is_called are
	// always 0 and true, respectively.
	SequenceSelectOp

	SequenceSelectPrivateOp

	// SetPrivate contains fields used by the relational set operators: Union,
	// Intersect, Except, UnionAll, IntersectAll, ExceptAll, and
	// LocalityOptimizedSearch. It matches columns from the left and right inputs of
	// the operator with the output columns, since OutputCols are not ordered and may
	// not correspond to each other.
	//
	// For example, consider the following query:
	//   SELECT y, x FROM xy UNION SELECT b, a FROM ab
	//
	// Given:
	//   col  index
	//   x    1
	//   y    2
	//   a    3
	//   b    4
	//
	// SetPrivate will contain the following values:
	//   Left:  [2, 1]
	//   Right: [4, 3]
	//   Out:   [5, 6]  <-- synthesized output columns
	//
	// To make normalization rules and execution simpler, both inputs to the set op
	// must have matching types.
	//
	// SetPrivate can also contain an optional ordering, allowing for more efficient
	// streaming execution.
	SetPrivateOp

	// ShowTraceForSession returns the current session traces.
	ShowTraceForSessionOp

	ShowTracePrivateOp

	SimilarToOp

	// Sort enforces the ordering of rows returned by its input expression. Rows can
	// be sorted by one or more of the input columns, each of which can be sorted in
	// either ascending or descending order. See the Ordering field in the
	// PhysicalProps struct.
	SortOp

	SqrDiffOp

	StdDevOp

	StdDevPopOp

	StringAggOp

	// Subquery is a subquery in a single-row context. Here are some examples:
	//
	//   SELECT 1 = (SELECT 1)
	//   SELECT (1, 'a') = (SELECT 1, 'a')`
	//
	// In a single-row context, the outer query is only valid if the subquery returns
	// at most one row. Subqueries in a multi-row context can be transformed to a
	// single row context using the Any operator. See the comment above the Any
	// operator for more details.
	//
	// The Input field contains the subquery itself, which should be wrapped in a
	// Max1Row operator to enforce that the subquery can return at most one row
	// (Max1Row may be removed by the optimizer later if it can determine statically
	// that the subquery will always return at most one row). In addition, the
	// subquery must project exactly one output column. If the subquery returns one
	// row, then that column is bound to the single column value in that row. If the
	// subquery returns zero rows, then that column is bound to NULL.
	SubqueryOp

	// SubqueryPrivate contains information related to a subquery (Subquery, Any,
	// Exists). It is shared between the operators so that the same rules can be used
	// across all the subquery operators.
	SubqueryPrivateOp

	SumOp

	SumIntOp

	// TopK returns the top K, where K is a constant, rows from the input set
	// according to its sort ordering, discarding the remaining rows. The Limit is a
	// constant positive integer; the operator returns at most Limit rows. Rows can
	// be sorted by one or more of the input columns, each of which can be sorted in
	// either ascending or descending order. See the Ordering field in the
	// PhysicalProps struct.
	//
	// Unlike the Limit relational operator, TopK does not require its input to be
	// ordered. However, if the input is known to have a partial ordering of the
	// required ordering, TopK can take advantage of optimizations. TopK can be used
	// to substitute a Limit that requires its input to be ordered and performs best
	// when the input is not already fully ordered. TopK scans the input, storing the
	// K rows that best meet the ordering requirement in a max heap, then sorts the K
	// rows.
	TopKOp

	TopKPrivateOp

	// True is the boolean true value that is equivalent to the tree.DBoolTrue datum
	// value. It is a separate operator to make matching and replacement simpler and
	// more efficient, as patterns can contain (True) expressions.
	TrueOp

	TupleOp

	UnaryCbrtOp

	UnaryComplementOp

	UnaryMinusOp

	UnaryPlusOp

	UnarySqrtOp

	// Union is an operator used to combine the Left and Right input relations into
	// a single set containing rows from both inputs. Duplicate rows are discarded.
	// The SetPrivate field matches columns from the Left and Right inputs of the
	// Union with the output columns. See the comment above SetPrivate for more
	// details.
	UnionOp

	// UnionAll is an operator used to combine the Left and Right input relations
	// into a single set containing rows from both inputs. Duplicate rows are
	// not discarded. For example:
	//
	//   SELECT x FROM xx UNION ALL SELECT y FROM yy
	//     x       y         out
	//   -----   -----      -----
	//     1       1          1
	//     1       2    ->    1
	//     2       3          1
	//                        2
	//                        2
	//                        3
	//
	// The SetPrivate field matches columns from the Left and Right inputs of the
	// UnionAll with the output columns. See the comment above SetPrivate for more
	// details.
	UnionAllOp

	// UniqueChecks is a list of uniqueness check queries, to be run after the main
	// query.
	UniqueChecksOp

	// UniqueChecksItem is a unique check query, to be run after the main query.
	// An execution error will be generated if the query returns any results.
	UniqueChecksItemOp

	UniqueChecksItemPrivateOp

	// Update evaluates a relational input expression that fetches existing rows from
	// a target table and computes new values for one or more columns. Arbitrary
	// subsets of rows can be selected from the target table and processed in order,
	// as with this example:
	//
	//   UPDATE abc SET b=10 WHERE a>0 ORDER BY b+c LIMIT 10
	//
	// The Update operator will also update any computed columns, including mutation
	// columns that are computed.
	UpdateOp

	// Upsert evaluates a relational input expression that tries to insert a new row
	// into a target table. If a conflicting row already exists, then Upsert will
	// instead update the existing row. The Upsert operator is used for all of these
	// syntactic variants:
	//
	//   INSERT..ON CONFLICT DO UPDATE
	//     INSERT INTO abc VALUES (1, 2, 3) ON CONFLICT (a) DO UPDATE SET b=10
	//
	//   INSERT..ON CONFLICT DO NOTHING
	//     INSERT INTO abc VALUES (1, 2, 3) ON CONFLICT DO NOTHING
	//
	//   UPSERT
	//     UPSERT INTO abc VALUES (1, 2, 3)
	//
	// The Update operator will also insert/update any computed columns, including
	// mutation columns that are computed.
	UpsertOp

	// UpsertDistinctOn is a variation on DistinctOn that is only used with UPSERT
	// and INSERT..ON CONFLICT statements. Unlike DistinctOn, UpsertDistinctOn treats
	// NULL values as not equal to one another for purposes of grouping. Two rows
	// having a NULL-valued grouping column will be placed in different groups. This
	// differs from DistinctOn behavior, where the two rows would be grouped
	// together. This behavior difference reflects SQL semantics, in which a unique
	// index key still allows multiple NULL values.
	//
	// UpsertDistinctOn is used when nulls are considered distinct for grouping
	// purposes and duplicates should be filtered out without raising an error.
	UpsertDistinctOnOp

	// Values returns a manufactured result set containing a constant number of rows.
	// specified by the Rows list field. Each row must contain the same set of
	// columns in the same order.
	//
	// The Rows field contains a list of Tuples, one for each row. Each tuple has
	// the same length (same with that of Cols).
	//
	// The Cols field contains the set of column indices returned by each row
	// as an opt.ColList. It is legal for Cols to be empty.
	ValuesOp

	ValuesPrivateOp

	VarPopOp

	// Variable is the typed scalar value of a column in the query. The Col field is
	// a metadata ColumnID value that references the column by index.
	VariableOp

	VarianceOp

	// When represents a single WHEN ... THEN ... condition inside a CASE statement.
	// It is the type of each list item in Whens (except for the last item which is
	// a raw expression for the ELSE statement).
	WhenOp

	// Window represents a window function. Window functions are operators which
	// allow computations that take into consideration other rows in the same result
	// set.
	//
	// More concretely, a window function is a relational operator that takes in a
	// result set and appends a single new column whose value depends on the other
	// rows within the result set, and that row's relative position in it.
	//
	// Depending on the exact window function being computed, the value of the new
	// column could be the position of the row in the output (`row_number`), or a
	// cumulative sum, or something else.
	WindowOp

	// WindowFromOffset is used as a modifier that wraps the input of a window
	// function. It supplies the expression to be used as the lower bound of the
	// window frame, if the lower bound uses OFFSET mode.
	WindowFromOffsetOp

	WindowPrivateOp

	// WindowToOffset is used as a modifier that wraps the input of a window
	// function. It supplies the expression to be used as the upper bound of the
	// window frame, if the upper bound uses OFFSET mode.
	WindowToOffsetOp

	// Windows is a set of window functions to be computed in the context of a
	// Window expression.
	WindowsOp

	// WindowsItem is a single window function to be computed in the context of a
	// Window expression.
	WindowsItemOp

	WindowsItemPrivateOp

	// With executes Binding, making its results available to Main. Within Main, the
	// results of Binding may be referenced by a WithScan expression containing the
	// ID of this With.
	WithOp

	WithPrivateOp

	// WithScan returns the results present in the With expression referenced
	// by ID.
	// Note that in order to construct a WithScan, the WithID must have a bound
	// expression in the metadata.
	WithScanOp

	WithScanPrivateOp

	XorAggOp

	// ZigzagJoin represents a join that is executed using the zigzag joiner.
	// All fields except for the ON expression are stored in the private;
	// since the zigzag joiner operates directly on indexes and doesn't
	// support arbitrary inputs.
	//
	// TODO(itsbilal): Add support for representing multi-way zigzag joins.
	ZigzagJoinOp

	ZigzagJoinPrivateOp

	// Zip represents a functional zip over generators a,b,c, which returns tuples of
	// values from a,b,c picked "simultaneously". NULLs are used when a generator is
	// "shorter" than another. In SQL, these generators can be either generator
	// functions such as generate_series(), or scalar functions or expressions such
	// as upper() or CAST. For example, consider this query:
	//
	//    SELECT * FROM ROWS FROM (generate_series(0, 1), upper('abc'));
	//
	// It is equivalent to:
	//
	//    (Zip [
	//            (ZipItem (Function generate_series)),
	//            (ZipItem (Function upper))
	//         ]
	//    )
	//
	// It produces:
	//
	//     generate_series | upper
	//    -----------------+-------
	//                   0 | ABC
	//                   1 | NULL
	//
	ZipOp

	// ZipItem contains a generator function or scalar expression that is contained
	// in a Zip. It also contains the list of output columns for the generator or
	// scalar expression in the ZipItem. Cols is a list since a single function may
	// output multiple columns (e.g. pg_get_keywords() outputs three columns).
	//
	// See the Zip header for more details.
	ZipItemOp

	NumOperators
)

const (
	InvalidRuleName RuleName = iota

	SimplifyRootOrdering
	PruneRootCols
	SimplifyZeroCardinalityGroup

	// NumManualRules tracks the number of manually-defined rules.
	NumManualRuleNames
)

const (

	// ------------------------------------------------------------
	// Normalize Rule Names
	// ------------------------------------------------------------
	EliminateAggDistinct RuleName
	NormalizeNestedAnds
	SimplifyTrueAnd
	SimplifyAndTrue
	SimplifyFalseAnd
	SimplifyAndFalse
	SimplifyTrueOr
	SimplifyOrTrue
	SimplifyFalseOr
	SimplifyOrFalse
	SimplifyRange
	FoldNullAndOr
	FoldNotTrue
	FoldNotFalse
	FoldNotNull
	NegateComparison
	EliminateNot
	NegateAnd
	NegateOr
	ExtractRedundantConjunct
	CommuteVarInequality
	CommuteConstInequality
	NormalizeCmpPlusConst
	NormalizeCmpMinusConst
	NormalizeCmpConstMinus
	NormalizeTupleEquality
	FoldNullComparisonLeft
	FoldNullComparisonRight
	FoldIsNull
	FoldNonNullIsNull
	FoldNullTupleIsTupleNull
	FoldNonNullTupleIsTupleNull
	FoldIsNotNull
	FoldNonNullIsNotNull
	FoldNonNullTupleIsTupleNotNull
	FoldNullTupleIsTupleNotNull
	CommuteNullIs
	NormalizeCmpTimeZoneFunction
	NormalizeCmpTimeZoneFunctionTZ
	FoldEqZeroSTDistance
	FoldCmpSTDistanceLeft
	FoldCmpSTDistanceRight
	FoldCmpSTMaxDistanceLeft
	FoldCmpSTMaxDistanceRight
	FoldEqTrue
	FoldEqFalse
	FoldNeTrue
	FoldNeFalse
	NormCycleTestRelTrueToFalse
	NormCycleTestRelFalseToTrue
	DecorrelateJoin
	DecorrelateProjectSet
	TryDecorrelateSelect
	TryDecorrelateProject
	TryDecorrelateProjectSelect
	TryDecorrelateProjectInnerJoin
	TryDecorrelateInnerJoin
	TryDecorrelateInnerLeftJoin
	TryDecorrelateGroupBy
	TryDecorrelateScalarGroupBy
	TryDecorrelateSemiJoin
	TryDecorrelateLimitOne
	TryDecorrelateLimit
	TryDecorrelateProjectSet
	TryDecorrelateWindow
	TryDecorrelateMax1Row
	HoistSelectExists
	HoistSelectNotExists
	HoistSelectSubquery
	HoistProjectSubquery
	HoistJoinSubquery
	HoistValuesSubquery
	HoistProjectSetSubquery
	NormalizeSelectAnyFilter
	NormalizeJoinAnyFilter
	NormalizeSelectNotAnyFilter
	NormalizeJoinNotAnyFilter
	FoldNullCast
	FoldNullUnary
	FoldNullBinaryLeft
	FoldNullBinaryRight
	FoldNullInNonEmpty
	FoldInEmpty
	FoldNotInEmpty
	FoldArray
	FoldBinary
	FoldUnary
	FoldComparison
	FoldCast
	FoldAssignmentCast
	FoldIndirection
	FoldColumnAccess
	FoldFunctionWithNullArg
	FoldFunction
	FoldEqualsAnyNull
	ConvertGroupByToDistinct
	EliminateGroupByProject
	EliminateJoinUnderGroupByLeft
	EliminateJoinUnderGroupByRight
	EliminateDistinct
	ReduceGroupingCols
	ReduceNotNullGroupingCols
	EliminateAggDistinctForKeys
	EliminateAggFilteredDistinctForKeys
	EliminateDistinctNoColumns
	EliminateEnsureDistinctNoColumns
	EliminateDistinctOnValues
	PushAggDistinctIntoGroupBy
	PushAggFilterIntoScalarGroupBy
	ConvertCountToCountRows
	ConvertRegressionCountToCount
	FoldGroupingOperators
	InlineConstVar
	InlineProjectConstants
	InlineSelectConstants
	InlineJoinConstantsLeft
	InlineJoinConstantsRight
	PushSelectIntoInlinableProject
	InlineSelectVirtualColumns
	InlineProjectInProject
	CommuteRightJoin
	SimplifyJoinFilters
	DetectJoinContradiction
	PushFilterIntoJoinLeftAndRight
	MapFilterIntoJoinLeft
	MapFilterIntoJoinRight
	MapEqualityIntoJoinLeftAndRight
	PushFilterIntoJoinLeft
	PushFilterIntoJoinRight
	SimplifyLeftJoin
	SimplifyRightJoin
	EliminateSemiJoin
	SimplifyZeroCardinalitySemiJoin
	EliminateAntiJoin
	SimplifyZeroCardinalityAntiJoin
	EliminateJoinNoColsLeft
	EliminateJoinNoColsRight
	HoistJoinProjectRight
	HoistJoinProjectLeft
	SimplifyJoinNotNullEquality
	ExtractJoinEqualities
	SortFiltersInJoin
	LeftAssociateJoinsLeft
	LeftAssociateJoinsRight
	RightAssociateJoinsLeft
	RightAssociateJoinsRight
	RemoveJoinNotNullCondition
	ProjectInnerJoinValues
	EliminateLimit
	EliminateOffset
	PushLimitIntoProject
	PushOffsetIntoProject
	PushLimitIntoOffset
	PushLimitIntoOrdinality
	PushLimitIntoJoinLeft
	PushLimitIntoJoinRight
	FoldLimits
	AssociateLimitJoinsLeft
	AssociateLimitJoinsRight
	EliminateMax1Row
	SimplifyPartialIndexProjections
	FoldPlusZero
	FoldZeroPlus
	FoldMinusZero
	FoldMultOne
	FoldOneMult
	FoldDivOne
	InvertMinus
	EliminateUnaryMinus
	SimplifyLimitOrdering
	SimplifyOffsetOrdering
	SimplifyGroupByOrdering
	SimplifyOrdinalityOrdering
	SimplifyExplainOrdering
	SimplifyWithBindingOrdering
	EliminateJoinUnderProjectLeft
	EliminateJoinUnderProjectRight
	EliminateProject
	MergeProjects
	MergeProjectWithValues
	PushColumnRemappingIntoValues
	PushAssignmentCastsIntoValues
	FoldTupleAccessIntoValues
	FoldJSONAccessIntoValues
	ConvertZipArraysToValues
	PruneProjectCols
	PruneScanCols
	PruneSelectCols
	PruneLimitCols
	PruneOffsetCols
	PruneJoinLeftCols
	PruneJoinRightCols
	PruneSemiAntiJoinRightCols
	PruneAggCols
	PruneGroupByCols
	PruneValuesCols
	PruneOrdinalityCols
	PruneExplainCols
	PruneProjectSetCols
	PruneWindowOutputCols
	PruneWindowInputCols
	PruneMutationFetchCols
	PruneMutationInputCols
	PruneMutationReturnCols
	PruneWithScanCols
	PruneWithCols
	PruneUnionAllCols
	RejectNullsLeftJoin
	RejectNullsRightJoin
	RejectNullsGroupBy
	RejectNullsUnderJoinLeft
	RejectNullsUnderJoinRight
	RejectNullsProject
	CommuteVar
	CommuteConst
	EliminateCoalesce
	SimplifyCoalesce
	EliminateCast
	NormalizeInConst
	FoldInNull
	SimplifyInSingleElement
	SimplifyNotInSingleElement
	UnifyComparisonTypes
	EliminateExistsZeroRows
	EliminateExistsProject
	EliminateExistsGroupBy
	InlineExistsSelectTuple
	IntroduceExistsLimit
	EliminateExistsLimit
	SimplifyCaseWhenConstValue
	InlineAnyValuesSingleCol
	InlineAnyValuesMultiCol
	SimplifyEqualsAnyTuple
	SimplifyAnyScalarArray
	FoldCollate
	NormalizeArrayFlattenToAgg
	SimplifySameVarEqualities
	SimplifySameVarInequalities
	SimplifyNotDisjoint
	SimplifySelectFilters
	ConsolidateSelectFilters
	DeduplicateSelectFilters
	EliminateSelect
	MergeSelects
	PushSelectIntoProject
	MergeSelectInnerJoin
	PushSelectCondLeftIntoJoinLeftAndRight
	PushSelectIntoJoinLeft
	PushSelectIntoGroupBy
	RemoveNotNullCondition
	PushSelectIntoProjectSet
	PushFilterIntoSetOp
	EliminateSetLeft
	EliminateSetRight
	EliminateDistinctSetLeft
	EliminateDistinctSetRight
	SimplifyExcept
	SimplifyIntersectLeft
	SimplifyIntersectRight
	ConvertUnionToDistinctUnionAll
	EliminateWindow
	ReduceWindowPartitionCols
	SimplifyWindowOrdering
	PushSelectIntoWindow
	PushLimitIntoWindow
	InlineWith

	// ------------------------------------------------------------
	// Explore Rule Names
	// ------------------------------------------------------------
	MemoCycleTestRelRule
	ReplaceScalarMinMaxWithScalarSubqueries
	ReplaceFilteredScalarMinMaxWithSubqueries
	ReplaceScalarMinMaxWithLimit
	ReplaceMinWithLimit
	ReplaceMaxWithLimit
	GenerateStreamingGroupBy
	SplitGroupByScanIntoUnionScans
	SplitGroupByFilteredScanIntoUnionScans
	EliminateIndexJoinOrProjectInsideGroupBy
	GenerateLimitedGroupByScans
	ReorderJoins
	CommuteLeftJoin
	CommuteSemiJoin
	ConvertSemiToInnerJoin
	GenerateMergeJoins
	GenerateLookupJoins
	GenerateInvertedJoins
	GenerateInvertedJoinsFromSelect
	GenerateLookupJoinsWithFilter
	GenerateLookupJoinsWithVirtualCols
	GenerateLookupJoinsWithVirtualColsAndFilter
	PushJoinIntoIndexJoin
	HoistProjectFromInnerJoin
	HoistProjectFromLeftJoin
	GenerateLocalityOptimizedAntiJoin
	GenerateLocalityOptimizedLookupJoin
	GenerateLimitedScans
	PushLimitIntoFilteredScan
	PushLimitIntoIndexJoin
	SplitLimitedScanIntoUnionScans
	SplitLimitedSelectIntoUnionSelects
	GenerateTopK
	GenerateLimitedTopKScans
	GeneratePartialOrderTopK
	EliminateIndexJoinInsideProject
	GenerateIndexScans
	GenerateLocalityOptimizedScan
	GeneratePartialIndexScans
	GenerateConstrainedScans
	GenerateInvertedIndexScans
	GenerateZigzagJoins
	GenerateInvertedIndexZigzagJoins
	SplitDisjunction
	SplitDisjunctionAddKey
	GenerateStreamingSetOp

	// NumRuleNames tracks the total count of rule names.
	NumRuleNames
)