polyglot_sql/
expressions.rs

1//! SQL Expression AST (Abstract Syntax Tree).
2//!
3//! This module defines all the AST node types used to represent parsed SQL
4//! statements and expressions. The design follows Python sqlglot's expression
5//! hierarchy, ported to a Rust enum-based AST.
6//!
7//! # Architecture
8//!
9//! The central type is [`Expression`], a large tagged enum with one variant per
10//! SQL construct. Inner structs carry the fields for each variant. Most
11//! heap-allocated variants are wrapped in `Box` to keep the enum size small.
12//!
13//! # Variant Groups
14//!
15//! | Group | Examples | Purpose |
16//! |---|---|---|
17//! | **Queries** | `Select`, `Union`, `Intersect`, `Except`, `Subquery` | Top-level query structures |
18//! | **DML** | `Insert`, `Update`, `Delete`, `Merge`, `Copy` | Data manipulation |
19//! | **DDL** | `CreateTable`, `AlterTable`, `DropView`, `CreateIndex` | Schema definition |
20//! | **Clauses** | `From`, `Join`, `Where`, `GroupBy`, `OrderBy`, `With` | Query clauses |
21//! | **Operators** | `And`, `Or`, `Add`, `Eq`, `Like`, `Not` | Binary and unary operations |
22//! | **Functions** | `Function`, `AggregateFunction`, `WindowFunction`, `Count`, `Sum` | Scalar, aggregate, and window functions |
23//! | **Literals** | `Literal`, `Boolean`, `Null`, `Interval` | Constant values |
24//! | **Types** | `DataType`, `Cast`, `TryCast`, `SafeCast` | Data types and casts |
25//! | **Identifiers** | `Identifier`, `Column`, `Table`, `Star` | Name references |
26//!
27//! # SQL Generation
28//!
29//! Every `Expression` can be rendered back to SQL via [`Expression::sql()`]
30//! (generic dialect) or [`Expression::sql_for()`] (specific dialect). The
31//! actual generation logic lives in the `generator` module.
32
33use crate::tokens::Span;
34use serde::{Deserialize, Serialize};
35use std::fmt;
36#[cfg(feature = "bindings")]
37use ts_rs::TS;
38
39/// Helper function for serde default value
40fn default_true() -> bool {
41    true
42}
43
44fn is_true(v: &bool) -> bool {
45    *v
46}
47
48/// Represent any SQL expression or statement as a single, recursive AST node.
49///
50/// `Expression` is the root type of the polyglot AST. Every parsed SQL
51/// construct -- from a simple integer literal to a multi-CTE query with
52/// window functions -- is represented as a variant of this enum.
53///
54/// Variants are organized into logical groups (see the module-level docs).
55/// Most non-trivial variants box their payload so that `size_of::<Expression>()`
56/// stays small (currently two words: tag + pointer).
57///
58/// # Constructing Expressions
59///
60/// Use the convenience constructors on `impl Expression` for common cases:
61///
62/// ```rust,ignore
63/// use polyglot_sql::expressions::Expression;
64///
65/// let col  = Expression::column("id");
66/// let lit  = Expression::number(42);
67/// let star = Expression::star();
68/// ```
69///
70/// # Generating SQL
71///
72/// ```rust,ignore
73/// let expr = Expression::column("name");
74/// assert_eq!(expr.sql(), "name");
75/// ```
76#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
77#[cfg_attr(feature = "bindings", derive(TS))]
78#[serde(rename_all = "snake_case")]
79#[cfg_attr(feature = "bindings", ts(export))]
80pub enum Expression {
81    // Literals
82    Literal(Box<Literal>),
83    Boolean(BooleanLiteral),
84    Null(Null),
85
86    // Identifiers
87    Identifier(Identifier),
88    Column(Box<Column>),
89    Table(Box<TableRef>),
90    Star(Star),
91    /// Snowflake braced wildcard syntax: {*}, {tbl.*}, {* EXCLUDE (...)}, {* ILIKE '...'}
92    BracedWildcard(Box<Expression>),
93
94    // Queries
95    Select(Box<Select>),
96    Union(Box<Union>),
97    Intersect(Box<Intersect>),
98    Except(Box<Except>),
99    Subquery(Box<Subquery>),
100    PipeOperator(Box<PipeOperator>),
101    Pivot(Box<Pivot>),
102    PivotAlias(Box<PivotAlias>),
103    Unpivot(Box<Unpivot>),
104    Values(Box<Values>),
105    PreWhere(Box<PreWhere>),
106    Stream(Box<Stream>),
107    UsingData(Box<UsingData>),
108    XmlNamespace(Box<XmlNamespace>),
109
110    // DML
111    Insert(Box<Insert>),
112    Update(Box<Update>),
113    Delete(Box<Delete>),
114    Copy(Box<CopyStmt>),
115    Put(Box<PutStmt>),
116    StageReference(Box<StageReference>),
117
118    // Expressions
119    Alias(Box<Alias>),
120    Cast(Box<Cast>),
121    Collation(Box<CollationExpr>),
122    Case(Box<Case>),
123
124    // Binary operations
125    And(Box<BinaryOp>),
126    Or(Box<BinaryOp>),
127    Add(Box<BinaryOp>),
128    Sub(Box<BinaryOp>),
129    Mul(Box<BinaryOp>),
130    Div(Box<BinaryOp>),
131    Mod(Box<BinaryOp>),
132    Eq(Box<BinaryOp>),
133    Neq(Box<BinaryOp>),
134    Lt(Box<BinaryOp>),
135    Lte(Box<BinaryOp>),
136    Gt(Box<BinaryOp>),
137    Gte(Box<BinaryOp>),
138    Like(Box<LikeOp>),
139    ILike(Box<LikeOp>),
140    /// SQLite MATCH operator (FTS)
141    Match(Box<BinaryOp>),
142    BitwiseAnd(Box<BinaryOp>),
143    BitwiseOr(Box<BinaryOp>),
144    BitwiseXor(Box<BinaryOp>),
145    Concat(Box<BinaryOp>),
146    Adjacent(Box<BinaryOp>),   // PostgreSQL range adjacency operator (-|-)
147    TsMatch(Box<BinaryOp>),    // PostgreSQL text search match operator (@@)
148    PropertyEQ(Box<BinaryOp>), // := assignment operator (MySQL @var := val, DuckDB named args)
149
150    // PostgreSQL array/JSONB operators
151    ArrayContainsAll(Box<BinaryOp>), // @> operator (array contains all)
152    ArrayContainedBy(Box<BinaryOp>), // <@ operator (array contained by)
153    ArrayOverlaps(Box<BinaryOp>),    // && operator (array overlaps)
154    JSONBContainsAllTopKeys(Box<BinaryOp>), // ?& operator (JSONB contains all keys)
155    JSONBContainsAnyTopKeys(Box<BinaryOp>), // ?| operator (JSONB contains any key)
156    JSONBDeleteAtPath(Box<BinaryOp>), // #- operator (JSONB delete at path)
157    ExtendsLeft(Box<BinaryOp>),      // &< operator (PostgreSQL range extends left)
158    ExtendsRight(Box<BinaryOp>),     // &> operator (PostgreSQL range extends right)
159
160    // Unary operations
161    Not(Box<UnaryOp>),
162    Neg(Box<UnaryOp>),
163    BitwiseNot(Box<UnaryOp>),
164
165    // Predicates
166    In(Box<In>),
167    Between(Box<Between>),
168    IsNull(Box<IsNull>),
169    IsTrue(Box<IsTrueFalse>),
170    IsFalse(Box<IsTrueFalse>),
171    IsJson(Box<IsJson>),
172    Is(Box<BinaryOp>), // General IS expression (e.g., a IS ?)
173    Exists(Box<Exists>),
174    /// MySQL MEMBER OF operator: expr MEMBER OF(json_array)
175    MemberOf(Box<BinaryOp>),
176
177    // Functions
178    Function(Box<Function>),
179    AggregateFunction(Box<AggregateFunction>),
180    WindowFunction(Box<WindowFunction>),
181
182    // Clauses
183    From(Box<From>),
184    Join(Box<Join>),
185    JoinedTable(Box<JoinedTable>),
186    Where(Box<Where>),
187    GroupBy(Box<GroupBy>),
188    Having(Box<Having>),
189    OrderBy(Box<OrderBy>),
190    Limit(Box<Limit>),
191    Offset(Box<Offset>),
192    Qualify(Box<Qualify>),
193    With(Box<With>),
194    Cte(Box<Cte>),
195    DistributeBy(Box<DistributeBy>),
196    ClusterBy(Box<ClusterBy>),
197    SortBy(Box<SortBy>),
198    LateralView(Box<LateralView>),
199    Hint(Box<Hint>),
200    Pseudocolumn(Pseudocolumn),
201
202    // Oracle hierarchical queries (CONNECT BY)
203    Connect(Box<Connect>),
204    Prior(Box<Prior>),
205    ConnectByRoot(Box<ConnectByRoot>),
206
207    // Pattern matching (MATCH_RECOGNIZE)
208    MatchRecognize(Box<MatchRecognize>),
209
210    // Order expressions
211    Ordered(Box<Ordered>),
212
213    // Window specifications
214    Window(Box<WindowSpec>),
215    Over(Box<Over>),
216    WithinGroup(Box<WithinGroup>),
217
218    // Data types
219    DataType(DataType),
220
221    // Arrays and structs
222    Array(Box<Array>),
223    Struct(Box<Struct>),
224    Tuple(Box<Tuple>),
225
226    // Interval
227    Interval(Box<Interval>),
228
229    // String functions
230    ConcatWs(Box<ConcatWs>),
231    Substring(Box<SubstringFunc>),
232    Upper(Box<UnaryFunc>),
233    Lower(Box<UnaryFunc>),
234    Length(Box<UnaryFunc>),
235    Trim(Box<TrimFunc>),
236    LTrim(Box<UnaryFunc>),
237    RTrim(Box<UnaryFunc>),
238    Replace(Box<ReplaceFunc>),
239    Reverse(Box<UnaryFunc>),
240    Left(Box<LeftRightFunc>),
241    Right(Box<LeftRightFunc>),
242    Repeat(Box<RepeatFunc>),
243    Lpad(Box<PadFunc>),
244    Rpad(Box<PadFunc>),
245    Split(Box<SplitFunc>),
246    RegexpLike(Box<RegexpFunc>),
247    RegexpReplace(Box<RegexpReplaceFunc>),
248    RegexpExtract(Box<RegexpExtractFunc>),
249    Overlay(Box<OverlayFunc>),
250
251    // Math functions
252    Abs(Box<UnaryFunc>),
253    Round(Box<RoundFunc>),
254    Floor(Box<FloorFunc>),
255    Ceil(Box<CeilFunc>),
256    Power(Box<BinaryFunc>),
257    Sqrt(Box<UnaryFunc>),
258    Cbrt(Box<UnaryFunc>),
259    Ln(Box<UnaryFunc>),
260    Log(Box<LogFunc>),
261    Exp(Box<UnaryFunc>),
262    Sign(Box<UnaryFunc>),
263    Greatest(Box<VarArgFunc>),
264    Least(Box<VarArgFunc>),
265
266    // Date/time functions
267    CurrentDate(CurrentDate),
268    CurrentTime(CurrentTime),
269    CurrentTimestamp(CurrentTimestamp),
270    CurrentTimestampLTZ(CurrentTimestampLTZ),
271    AtTimeZone(Box<AtTimeZone>),
272    DateAdd(Box<DateAddFunc>),
273    DateSub(Box<DateAddFunc>),
274    DateDiff(Box<DateDiffFunc>),
275    DateTrunc(Box<DateTruncFunc>),
276    Extract(Box<ExtractFunc>),
277    ToDate(Box<ToDateFunc>),
278    ToTimestamp(Box<ToTimestampFunc>),
279    Date(Box<UnaryFunc>),
280    Time(Box<UnaryFunc>),
281    DateFromUnixDate(Box<UnaryFunc>),
282    UnixDate(Box<UnaryFunc>),
283    UnixSeconds(Box<UnaryFunc>),
284    UnixMillis(Box<UnaryFunc>),
285    UnixMicros(Box<UnaryFunc>),
286    UnixToTimeStr(Box<BinaryFunc>),
287    TimeStrToDate(Box<UnaryFunc>),
288    DateToDi(Box<UnaryFunc>),
289    DiToDate(Box<UnaryFunc>),
290    TsOrDiToDi(Box<UnaryFunc>),
291    TsOrDsToDatetime(Box<UnaryFunc>),
292    TsOrDsToTimestamp(Box<UnaryFunc>),
293    YearOfWeek(Box<UnaryFunc>),
294    YearOfWeekIso(Box<UnaryFunc>),
295
296    // Control flow functions
297    Coalesce(Box<VarArgFunc>),
298    NullIf(Box<BinaryFunc>),
299    IfFunc(Box<IfFunc>),
300    IfNull(Box<BinaryFunc>),
301    Nvl(Box<BinaryFunc>),
302    Nvl2(Box<Nvl2Func>),
303
304    // Type conversion
305    TryCast(Box<Cast>),
306    SafeCast(Box<Cast>),
307
308    // Typed aggregate functions
309    Count(Box<CountFunc>),
310    Sum(Box<AggFunc>),
311    Avg(Box<AggFunc>),
312    Min(Box<AggFunc>),
313    Max(Box<AggFunc>),
314    GroupConcat(Box<GroupConcatFunc>),
315    StringAgg(Box<StringAggFunc>),
316    ListAgg(Box<ListAggFunc>),
317    ArrayAgg(Box<AggFunc>),
318    CountIf(Box<AggFunc>),
319    SumIf(Box<SumIfFunc>),
320    Stddev(Box<AggFunc>),
321    StddevPop(Box<AggFunc>),
322    StddevSamp(Box<AggFunc>),
323    Variance(Box<AggFunc>),
324    VarPop(Box<AggFunc>),
325    VarSamp(Box<AggFunc>),
326    Median(Box<AggFunc>),
327    Mode(Box<AggFunc>),
328    First(Box<AggFunc>),
329    Last(Box<AggFunc>),
330    AnyValue(Box<AggFunc>),
331    ApproxDistinct(Box<AggFunc>),
332    ApproxCountDistinct(Box<AggFunc>),
333    ApproxPercentile(Box<ApproxPercentileFunc>),
334    Percentile(Box<PercentileFunc>),
335    LogicalAnd(Box<AggFunc>),
336    LogicalOr(Box<AggFunc>),
337    Skewness(Box<AggFunc>),
338    BitwiseCount(Box<UnaryFunc>),
339    ArrayConcatAgg(Box<AggFunc>),
340    ArrayUniqueAgg(Box<AggFunc>),
341    BoolXorAgg(Box<AggFunc>),
342
343    // Typed window functions
344    RowNumber(RowNumber),
345    Rank(Rank),
346    DenseRank(DenseRank),
347    NTile(Box<NTileFunc>),
348    Lead(Box<LeadLagFunc>),
349    Lag(Box<LeadLagFunc>),
350    FirstValue(Box<ValueFunc>),
351    LastValue(Box<ValueFunc>),
352    NthValue(Box<NthValueFunc>),
353    PercentRank(PercentRank),
354    CumeDist(CumeDist),
355    PercentileCont(Box<PercentileFunc>),
356    PercentileDisc(Box<PercentileFunc>),
357
358    // Additional string functions
359    Contains(Box<BinaryFunc>),
360    StartsWith(Box<BinaryFunc>),
361    EndsWith(Box<BinaryFunc>),
362    Position(Box<PositionFunc>),
363    Initcap(Box<UnaryFunc>),
364    Ascii(Box<UnaryFunc>),
365    Chr(Box<UnaryFunc>),
366    /// MySQL CHAR function with multiple args and optional USING charset
367    CharFunc(Box<CharFunc>),
368    Soundex(Box<UnaryFunc>),
369    Levenshtein(Box<BinaryFunc>),
370    ByteLength(Box<UnaryFunc>),
371    Hex(Box<UnaryFunc>),
372    LowerHex(Box<UnaryFunc>),
373    Unicode(Box<UnaryFunc>),
374
375    // Additional math functions
376    ModFunc(Box<BinaryFunc>),
377    Random(Random),
378    Rand(Box<Rand>),
379    TruncFunc(Box<TruncateFunc>),
380    Pi(Pi),
381    Radians(Box<UnaryFunc>),
382    Degrees(Box<UnaryFunc>),
383    Sin(Box<UnaryFunc>),
384    Cos(Box<UnaryFunc>),
385    Tan(Box<UnaryFunc>),
386    Asin(Box<UnaryFunc>),
387    Acos(Box<UnaryFunc>),
388    Atan(Box<UnaryFunc>),
389    Atan2(Box<BinaryFunc>),
390    IsNan(Box<UnaryFunc>),
391    IsInf(Box<UnaryFunc>),
392    IntDiv(Box<BinaryFunc>),
393
394    // Control flow
395    Decode(Box<DecodeFunc>),
396
397    // Additional date/time functions
398    DateFormat(Box<DateFormatFunc>),
399    FormatDate(Box<DateFormatFunc>),
400    Year(Box<UnaryFunc>),
401    Month(Box<UnaryFunc>),
402    Day(Box<UnaryFunc>),
403    Hour(Box<UnaryFunc>),
404    Minute(Box<UnaryFunc>),
405    Second(Box<UnaryFunc>),
406    DayOfWeek(Box<UnaryFunc>),
407    DayOfWeekIso(Box<UnaryFunc>),
408    DayOfMonth(Box<UnaryFunc>),
409    DayOfYear(Box<UnaryFunc>),
410    WeekOfYear(Box<UnaryFunc>),
411    Quarter(Box<UnaryFunc>),
412    AddMonths(Box<BinaryFunc>),
413    MonthsBetween(Box<BinaryFunc>),
414    LastDay(Box<LastDayFunc>),
415    NextDay(Box<BinaryFunc>),
416    Epoch(Box<UnaryFunc>),
417    EpochMs(Box<UnaryFunc>),
418    FromUnixtime(Box<FromUnixtimeFunc>),
419    UnixTimestamp(Box<UnixTimestampFunc>),
420    MakeDate(Box<MakeDateFunc>),
421    MakeTimestamp(Box<MakeTimestampFunc>),
422    TimestampTrunc(Box<DateTruncFunc>),
423    TimeStrToUnix(Box<UnaryFunc>),
424
425    // Session/User functions
426    SessionUser(SessionUser),
427
428    // Hash/Crypto functions
429    SHA(Box<UnaryFunc>),
430    SHA1Digest(Box<UnaryFunc>),
431
432    // Time conversion functions
433    TimeToUnix(Box<UnaryFunc>),
434
435    // Array functions
436    ArrayFunc(Box<ArrayConstructor>),
437    ArrayLength(Box<UnaryFunc>),
438    ArraySize(Box<UnaryFunc>),
439    Cardinality(Box<UnaryFunc>),
440    ArrayContains(Box<BinaryFunc>),
441    ArrayPosition(Box<BinaryFunc>),
442    ArrayAppend(Box<BinaryFunc>),
443    ArrayPrepend(Box<BinaryFunc>),
444    ArrayConcat(Box<VarArgFunc>),
445    ArraySort(Box<ArraySortFunc>),
446    ArrayReverse(Box<UnaryFunc>),
447    ArrayDistinct(Box<UnaryFunc>),
448    ArrayJoin(Box<ArrayJoinFunc>),
449    ArrayToString(Box<ArrayJoinFunc>),
450    Unnest(Box<UnnestFunc>),
451    Explode(Box<UnaryFunc>),
452    ExplodeOuter(Box<UnaryFunc>),
453    ArrayFilter(Box<ArrayFilterFunc>),
454    ArrayTransform(Box<ArrayTransformFunc>),
455    ArrayFlatten(Box<UnaryFunc>),
456    ArrayCompact(Box<UnaryFunc>),
457    ArrayIntersect(Box<VarArgFunc>),
458    ArrayUnion(Box<BinaryFunc>),
459    ArrayExcept(Box<BinaryFunc>),
460    ArrayRemove(Box<BinaryFunc>),
461    ArrayZip(Box<VarArgFunc>),
462    Sequence(Box<SequenceFunc>),
463    Generate(Box<SequenceFunc>),
464    ExplodingGenerateSeries(Box<SequenceFunc>),
465    ToArray(Box<UnaryFunc>),
466    StarMap(Box<BinaryFunc>),
467
468    // Struct functions
469    StructFunc(Box<StructConstructor>),
470    StructExtract(Box<StructExtractFunc>),
471    NamedStruct(Box<NamedStructFunc>),
472
473    // Map functions
474    MapFunc(Box<MapConstructor>),
475    MapFromEntries(Box<UnaryFunc>),
476    MapFromArrays(Box<BinaryFunc>),
477    MapKeys(Box<UnaryFunc>),
478    MapValues(Box<UnaryFunc>),
479    MapContainsKey(Box<BinaryFunc>),
480    MapConcat(Box<VarArgFunc>),
481    ElementAt(Box<BinaryFunc>),
482    TransformKeys(Box<TransformFunc>),
483    TransformValues(Box<TransformFunc>),
484
485    // Exasol: function call with EMITS clause
486    FunctionEmits(Box<FunctionEmits>),
487
488    // JSON functions
489    JsonExtract(Box<JsonExtractFunc>),
490    JsonExtractScalar(Box<JsonExtractFunc>),
491    JsonExtractPath(Box<JsonPathFunc>),
492    JsonArray(Box<VarArgFunc>),
493    JsonObject(Box<JsonObjectFunc>),
494    JsonQuery(Box<JsonExtractFunc>),
495    JsonValue(Box<JsonExtractFunc>),
496    JsonArrayLength(Box<UnaryFunc>),
497    JsonKeys(Box<UnaryFunc>),
498    JsonType(Box<UnaryFunc>),
499    ParseJson(Box<UnaryFunc>),
500    ToJson(Box<UnaryFunc>),
501    JsonSet(Box<JsonModifyFunc>),
502    JsonInsert(Box<JsonModifyFunc>),
503    JsonRemove(Box<JsonPathFunc>),
504    JsonMergePatch(Box<BinaryFunc>),
505    JsonArrayAgg(Box<JsonArrayAggFunc>),
506    JsonObjectAgg(Box<JsonObjectAggFunc>),
507
508    // Type casting/conversion
509    Convert(Box<ConvertFunc>),
510    Typeof(Box<UnaryFunc>),
511
512    // Additional expressions
513    Lambda(Box<LambdaExpr>),
514    Parameter(Box<Parameter>),
515    Placeholder(Placeholder),
516    NamedArgument(Box<NamedArgument>),
517    /// TABLE ref or MODEL ref used as a function argument (BigQuery)
518    /// e.g., GAP_FILL(TABLE device_data, ...) or ML.PREDICT(MODEL mydataset.mymodel, ...)
519    TableArgument(Box<TableArgument>),
520    SqlComment(Box<SqlComment>),
521
522    // Additional predicates
523    NullSafeEq(Box<BinaryOp>),
524    NullSafeNeq(Box<BinaryOp>),
525    Glob(Box<BinaryOp>),
526    SimilarTo(Box<SimilarToExpr>),
527    Any(Box<QuantifiedExpr>),
528    All(Box<QuantifiedExpr>),
529    Overlaps(Box<OverlapsExpr>),
530
531    // Bitwise operations
532    BitwiseLeftShift(Box<BinaryOp>),
533    BitwiseRightShift(Box<BinaryOp>),
534    BitwiseAndAgg(Box<AggFunc>),
535    BitwiseOrAgg(Box<AggFunc>),
536    BitwiseXorAgg(Box<AggFunc>),
537
538    // Array/struct/map access
539    Subscript(Box<Subscript>),
540    Dot(Box<DotAccess>),
541    MethodCall(Box<MethodCall>),
542    ArraySlice(Box<ArraySlice>),
543
544    // DDL statements
545    CreateTable(Box<CreateTable>),
546    DropTable(Box<DropTable>),
547    AlterTable(Box<AlterTable>),
548    CreateIndex(Box<CreateIndex>),
549    DropIndex(Box<DropIndex>),
550    CreateView(Box<CreateView>),
551    DropView(Box<DropView>),
552    AlterView(Box<AlterView>),
553    AlterIndex(Box<AlterIndex>),
554    Truncate(Box<Truncate>),
555    Use(Box<Use>),
556    Cache(Box<Cache>),
557    Uncache(Box<Uncache>),
558    LoadData(Box<LoadData>),
559    Pragma(Box<Pragma>),
560    Grant(Box<Grant>),
561    Revoke(Box<Revoke>),
562    Comment(Box<Comment>),
563    SetStatement(Box<SetStatement>),
564    // Phase 4: Additional DDL statements
565    CreateSchema(Box<CreateSchema>),
566    DropSchema(Box<DropSchema>),
567    DropNamespace(Box<DropNamespace>),
568    CreateDatabase(Box<CreateDatabase>),
569    DropDatabase(Box<DropDatabase>),
570    CreateFunction(Box<CreateFunction>),
571    DropFunction(Box<DropFunction>),
572    CreateProcedure(Box<CreateProcedure>),
573    DropProcedure(Box<DropProcedure>),
574    CreateSequence(Box<CreateSequence>),
575    CreateSynonym(Box<CreateSynonym>),
576    DropSequence(Box<DropSequence>),
577    AlterSequence(Box<AlterSequence>),
578    CreateTrigger(Box<CreateTrigger>),
579    DropTrigger(Box<DropTrigger>),
580    CreateType(Box<CreateType>),
581    DropType(Box<DropType>),
582    Describe(Box<Describe>),
583    Show(Box<Show>),
584
585    // Transaction and other commands
586    Command(Box<Command>),
587    Kill(Box<Kill>),
588    /// EXEC/EXECUTE statement (TSQL stored procedure call)
589    Execute(Box<ExecuteStatement>),
590
591    /// Snowflake CREATE TASK statement
592    CreateTask(Box<CreateTask>),
593
594    // Placeholder for unparsed/raw SQL
595    Raw(Raw),
596
597    // Paren for grouping
598    Paren(Box<Paren>),
599
600    // Expression with trailing comments (for round-trip preservation)
601    Annotated(Box<Annotated>),
602
603    // === BATCH GENERATED EXPRESSION TYPES ===
604    // Generated from Python sqlglot expressions.py
605    Refresh(Box<Refresh>),
606    LockingStatement(Box<LockingStatement>),
607    SequenceProperties(Box<SequenceProperties>),
608    TruncateTable(Box<TruncateTable>),
609    Clone(Box<Clone>),
610    Attach(Box<Attach>),
611    Detach(Box<Detach>),
612    Install(Box<Install>),
613    Summarize(Box<Summarize>),
614    Declare(Box<Declare>),
615    DeclareItem(Box<DeclareItem>),
616    Set(Box<Set>),
617    Heredoc(Box<Heredoc>),
618    SetItem(Box<SetItem>),
619    QueryBand(Box<QueryBand>),
620    UserDefinedFunction(Box<UserDefinedFunction>),
621    RecursiveWithSearch(Box<RecursiveWithSearch>),
622    ProjectionDef(Box<ProjectionDef>),
623    TableAlias(Box<TableAlias>),
624    ByteString(Box<ByteString>),
625    HexStringExpr(Box<HexStringExpr>),
626    UnicodeString(Box<UnicodeString>),
627    ColumnPosition(Box<ColumnPosition>),
628    ColumnDef(Box<ColumnDef>),
629    AlterColumn(Box<AlterColumn>),
630    AlterSortKey(Box<AlterSortKey>),
631    AlterSet(Box<AlterSet>),
632    RenameColumn(Box<RenameColumn>),
633    Comprehension(Box<Comprehension>),
634    MergeTreeTTLAction(Box<MergeTreeTTLAction>),
635    MergeTreeTTL(Box<MergeTreeTTL>),
636    IndexConstraintOption(Box<IndexConstraintOption>),
637    ColumnConstraint(Box<ColumnConstraint>),
638    PeriodForSystemTimeConstraint(Box<PeriodForSystemTimeConstraint>),
639    CaseSpecificColumnConstraint(Box<CaseSpecificColumnConstraint>),
640    CharacterSetColumnConstraint(Box<CharacterSetColumnConstraint>),
641    CheckColumnConstraint(Box<CheckColumnConstraint>),
642    AssumeColumnConstraint(Box<AssumeColumnConstraint>),
643    CompressColumnConstraint(Box<CompressColumnConstraint>),
644    DateFormatColumnConstraint(Box<DateFormatColumnConstraint>),
645    EphemeralColumnConstraint(Box<EphemeralColumnConstraint>),
646    WithOperator(Box<WithOperator>),
647    GeneratedAsIdentityColumnConstraint(Box<GeneratedAsIdentityColumnConstraint>),
648    AutoIncrementColumnConstraint(AutoIncrementColumnConstraint),
649    CommentColumnConstraint(CommentColumnConstraint),
650    GeneratedAsRowColumnConstraint(Box<GeneratedAsRowColumnConstraint>),
651    IndexColumnConstraint(Box<IndexColumnConstraint>),
652    MaskingPolicyColumnConstraint(Box<MaskingPolicyColumnConstraint>),
653    NotNullColumnConstraint(Box<NotNullColumnConstraint>),
654    PrimaryKeyColumnConstraint(Box<PrimaryKeyColumnConstraint>),
655    UniqueColumnConstraint(Box<UniqueColumnConstraint>),
656    WatermarkColumnConstraint(Box<WatermarkColumnConstraint>),
657    ComputedColumnConstraint(Box<ComputedColumnConstraint>),
658    InOutColumnConstraint(Box<InOutColumnConstraint>),
659    DefaultColumnConstraint(Box<DefaultColumnConstraint>),
660    PathColumnConstraint(Box<PathColumnConstraint>),
661    Constraint(Box<Constraint>),
662    Export(Box<Export>),
663    Filter(Box<Filter>),
664    Changes(Box<Changes>),
665    CopyParameter(Box<CopyParameter>),
666    Credentials(Box<Credentials>),
667    Directory(Box<Directory>),
668    ForeignKey(Box<ForeignKey>),
669    ColumnPrefix(Box<ColumnPrefix>),
670    PrimaryKey(Box<PrimaryKey>),
671    IntoClause(Box<IntoClause>),
672    JoinHint(Box<JoinHint>),
673    Opclass(Box<Opclass>),
674    Index(Box<Index>),
675    IndexParameters(Box<IndexParameters>),
676    ConditionalInsert(Box<ConditionalInsert>),
677    MultitableInserts(Box<MultitableInserts>),
678    OnConflict(Box<OnConflict>),
679    OnCondition(Box<OnCondition>),
680    Returning(Box<Returning>),
681    Introducer(Box<Introducer>),
682    PartitionRange(Box<PartitionRange>),
683    Fetch(Box<Fetch>),
684    Group(Box<Group>),
685    Cube(Box<Cube>),
686    Rollup(Box<Rollup>),
687    GroupingSets(Box<GroupingSets>),
688    LimitOptions(Box<LimitOptions>),
689    Lateral(Box<Lateral>),
690    TableFromRows(Box<TableFromRows>),
691    RowsFrom(Box<RowsFrom>),
692    MatchRecognizeMeasure(Box<MatchRecognizeMeasure>),
693    WithFill(Box<WithFill>),
694    Property(Box<Property>),
695    GrantPrivilege(Box<GrantPrivilege>),
696    GrantPrincipal(Box<GrantPrincipal>),
697    AllowedValuesProperty(Box<AllowedValuesProperty>),
698    AlgorithmProperty(Box<AlgorithmProperty>),
699    AutoIncrementProperty(Box<AutoIncrementProperty>),
700    AutoRefreshProperty(Box<AutoRefreshProperty>),
701    BackupProperty(Box<BackupProperty>),
702    BuildProperty(Box<BuildProperty>),
703    BlockCompressionProperty(Box<BlockCompressionProperty>),
704    CharacterSetProperty(Box<CharacterSetProperty>),
705    ChecksumProperty(Box<ChecksumProperty>),
706    CollateProperty(Box<CollateProperty>),
707    DataBlocksizeProperty(Box<DataBlocksizeProperty>),
708    DataDeletionProperty(Box<DataDeletionProperty>),
709    DefinerProperty(Box<DefinerProperty>),
710    DistKeyProperty(Box<DistKeyProperty>),
711    DistributedByProperty(Box<DistributedByProperty>),
712    DistStyleProperty(Box<DistStyleProperty>),
713    DuplicateKeyProperty(Box<DuplicateKeyProperty>),
714    EngineProperty(Box<EngineProperty>),
715    ToTableProperty(Box<ToTableProperty>),
716    ExecuteAsProperty(Box<ExecuteAsProperty>),
717    ExternalProperty(Box<ExternalProperty>),
718    FallbackProperty(Box<FallbackProperty>),
719    FileFormatProperty(Box<FileFormatProperty>),
720    CredentialsProperty(Box<CredentialsProperty>),
721    FreespaceProperty(Box<FreespaceProperty>),
722    InheritsProperty(Box<InheritsProperty>),
723    InputModelProperty(Box<InputModelProperty>),
724    OutputModelProperty(Box<OutputModelProperty>),
725    IsolatedLoadingProperty(Box<IsolatedLoadingProperty>),
726    JournalProperty(Box<JournalProperty>),
727    LanguageProperty(Box<LanguageProperty>),
728    EnviromentProperty(Box<EnviromentProperty>),
729    ClusteredByProperty(Box<ClusteredByProperty>),
730    DictProperty(Box<DictProperty>),
731    DictRange(Box<DictRange>),
732    OnCluster(Box<OnCluster>),
733    LikeProperty(Box<LikeProperty>),
734    LocationProperty(Box<LocationProperty>),
735    LockProperty(Box<LockProperty>),
736    LockingProperty(Box<LockingProperty>),
737    LogProperty(Box<LogProperty>),
738    MaterializedProperty(Box<MaterializedProperty>),
739    MergeBlockRatioProperty(Box<MergeBlockRatioProperty>),
740    OnProperty(Box<OnProperty>),
741    OnCommitProperty(Box<OnCommitProperty>),
742    PartitionedByProperty(Box<PartitionedByProperty>),
743    PartitionByProperty(Box<PartitionByProperty>),
744    PartitionedByBucket(Box<PartitionedByBucket>),
745    ClusterByColumnsProperty(Box<ClusterByColumnsProperty>),
746    PartitionByTruncate(Box<PartitionByTruncate>),
747    PartitionByRangeProperty(Box<PartitionByRangeProperty>),
748    PartitionByRangePropertyDynamic(Box<PartitionByRangePropertyDynamic>),
749    PartitionByListProperty(Box<PartitionByListProperty>),
750    PartitionList(Box<PartitionList>),
751    Partition(Box<Partition>),
752    RefreshTriggerProperty(Box<RefreshTriggerProperty>),
753    UniqueKeyProperty(Box<UniqueKeyProperty>),
754    RollupProperty(Box<RollupProperty>),
755    PartitionBoundSpec(Box<PartitionBoundSpec>),
756    PartitionedOfProperty(Box<PartitionedOfProperty>),
757    RemoteWithConnectionModelProperty(Box<RemoteWithConnectionModelProperty>),
758    ReturnsProperty(Box<ReturnsProperty>),
759    RowFormatProperty(Box<RowFormatProperty>),
760    RowFormatDelimitedProperty(Box<RowFormatDelimitedProperty>),
761    RowFormatSerdeProperty(Box<RowFormatSerdeProperty>),
762    QueryTransform(Box<QueryTransform>),
763    SampleProperty(Box<SampleProperty>),
764    SecurityProperty(Box<SecurityProperty>),
765    SchemaCommentProperty(Box<SchemaCommentProperty>),
766    SemanticView(Box<SemanticView>),
767    SerdeProperties(Box<SerdeProperties>),
768    SetProperty(Box<SetProperty>),
769    SharingProperty(Box<SharingProperty>),
770    SetConfigProperty(Box<SetConfigProperty>),
771    SettingsProperty(Box<SettingsProperty>),
772    SortKeyProperty(Box<SortKeyProperty>),
773    SqlReadWriteProperty(Box<SqlReadWriteProperty>),
774    SqlSecurityProperty(Box<SqlSecurityProperty>),
775    StabilityProperty(Box<StabilityProperty>),
776    StorageHandlerProperty(Box<StorageHandlerProperty>),
777    TemporaryProperty(Box<TemporaryProperty>),
778    Tags(Box<Tags>),
779    TransformModelProperty(Box<TransformModelProperty>),
780    TransientProperty(Box<TransientProperty>),
781    UsingTemplateProperty(Box<UsingTemplateProperty>),
782    ViewAttributeProperty(Box<ViewAttributeProperty>),
783    VolatileProperty(Box<VolatileProperty>),
784    WithDataProperty(Box<WithDataProperty>),
785    WithJournalTableProperty(Box<WithJournalTableProperty>),
786    WithSchemaBindingProperty(Box<WithSchemaBindingProperty>),
787    WithSystemVersioningProperty(Box<WithSystemVersioningProperty>),
788    WithProcedureOptions(Box<WithProcedureOptions>),
789    EncodeProperty(Box<EncodeProperty>),
790    IncludeProperty(Box<IncludeProperty>),
791    Properties(Box<Properties>),
792    OptionsProperty(Box<OptionsProperty>),
793    InputOutputFormat(Box<InputOutputFormat>),
794    Reference(Box<Reference>),
795    QueryOption(Box<QueryOption>),
796    WithTableHint(Box<WithTableHint>),
797    IndexTableHint(Box<IndexTableHint>),
798    HistoricalData(Box<HistoricalData>),
799    Get(Box<Get>),
800    SetOperation(Box<SetOperation>),
801    Var(Box<Var>),
802    Variadic(Box<Variadic>),
803    Version(Box<Version>),
804    Schema(Box<Schema>),
805    Lock(Box<Lock>),
806    TableSample(Box<TableSample>),
807    Tag(Box<Tag>),
808    UnpivotColumns(Box<UnpivotColumns>),
809    WindowSpec(Box<WindowSpec>),
810    SessionParameter(Box<SessionParameter>),
811    PseudoType(Box<PseudoType>),
812    ObjectIdentifier(Box<ObjectIdentifier>),
813    Transaction(Box<Transaction>),
814    Commit(Box<Commit>),
815    Rollback(Box<Rollback>),
816    AlterSession(Box<AlterSession>),
817    Analyze(Box<Analyze>),
818    AnalyzeStatistics(Box<AnalyzeStatistics>),
819    AnalyzeHistogram(Box<AnalyzeHistogram>),
820    AnalyzeSample(Box<AnalyzeSample>),
821    AnalyzeListChainedRows(Box<AnalyzeListChainedRows>),
822    AnalyzeDelete(Box<AnalyzeDelete>),
823    AnalyzeWith(Box<AnalyzeWith>),
824    AnalyzeValidate(Box<AnalyzeValidate>),
825    AddPartition(Box<AddPartition>),
826    AttachOption(Box<AttachOption>),
827    DropPartition(Box<DropPartition>),
828    ReplacePartition(Box<ReplacePartition>),
829    DPipe(Box<DPipe>),
830    Operator(Box<Operator>),
831    PivotAny(Box<PivotAny>),
832    Aliases(Box<Aliases>),
833    AtIndex(Box<AtIndex>),
834    FromTimeZone(Box<FromTimeZone>),
835    FormatPhrase(Box<FormatPhrase>),
836    ForIn(Box<ForIn>),
837    TimeUnit(Box<TimeUnit>),
838    IntervalOp(Box<IntervalOp>),
839    IntervalSpan(Box<IntervalSpan>),
840    HavingMax(Box<HavingMax>),
841    CosineDistance(Box<CosineDistance>),
842    DotProduct(Box<DotProduct>),
843    EuclideanDistance(Box<EuclideanDistance>),
844    ManhattanDistance(Box<ManhattanDistance>),
845    JarowinklerSimilarity(Box<JarowinklerSimilarity>),
846    Booland(Box<Booland>),
847    Boolor(Box<Boolor>),
848    ParameterizedAgg(Box<ParameterizedAgg>),
849    ArgMax(Box<ArgMax>),
850    ArgMin(Box<ArgMin>),
851    ApproxTopK(Box<ApproxTopK>),
852    ApproxTopKAccumulate(Box<ApproxTopKAccumulate>),
853    ApproxTopKCombine(Box<ApproxTopKCombine>),
854    ApproxTopKEstimate(Box<ApproxTopKEstimate>),
855    ApproxTopSum(Box<ApproxTopSum>),
856    ApproxQuantiles(Box<ApproxQuantiles>),
857    Minhash(Box<Minhash>),
858    FarmFingerprint(Box<FarmFingerprint>),
859    Float64(Box<Float64>),
860    Transform(Box<Transform>),
861    Translate(Box<Translate>),
862    Grouping(Box<Grouping>),
863    GroupingId(Box<GroupingId>),
864    Anonymous(Box<Anonymous>),
865    AnonymousAggFunc(Box<AnonymousAggFunc>),
866    CombinedAggFunc(Box<CombinedAggFunc>),
867    CombinedParameterizedAgg(Box<CombinedParameterizedAgg>),
868    HashAgg(Box<HashAgg>),
869    Hll(Box<Hll>),
870    Apply(Box<Apply>),
871    ToBoolean(Box<ToBoolean>),
872    List(Box<List>),
873    ToMap(Box<ToMap>),
874    Pad(Box<Pad>),
875    ToChar(Box<ToChar>),
876    ToNumber(Box<ToNumber>),
877    ToDouble(Box<ToDouble>),
878    Int64(Box<UnaryFunc>),
879    StringFunc(Box<StringFunc>),
880    ToDecfloat(Box<ToDecfloat>),
881    TryToDecfloat(Box<TryToDecfloat>),
882    ToFile(Box<ToFile>),
883    Columns(Box<Columns>),
884    ConvertToCharset(Box<ConvertToCharset>),
885    ConvertTimezone(Box<ConvertTimezone>),
886    GenerateSeries(Box<GenerateSeries>),
887    AIAgg(Box<AIAgg>),
888    AIClassify(Box<AIClassify>),
889    ArrayAll(Box<ArrayAll>),
890    ArrayAny(Box<ArrayAny>),
891    ArrayConstructCompact(Box<ArrayConstructCompact>),
892    StPoint(Box<StPoint>),
893    StDistance(Box<StDistance>),
894    StringToArray(Box<StringToArray>),
895    ArraySum(Box<ArraySum>),
896    ObjectAgg(Box<ObjectAgg>),
897    CastToStrType(Box<CastToStrType>),
898    CheckJson(Box<CheckJson>),
899    CheckXml(Box<CheckXml>),
900    TranslateCharacters(Box<TranslateCharacters>),
901    CurrentSchemas(Box<CurrentSchemas>),
902    CurrentDatetime(Box<CurrentDatetime>),
903    Localtime(Box<Localtime>),
904    Localtimestamp(Box<Localtimestamp>),
905    Systimestamp(Box<Systimestamp>),
906    CurrentSchema(Box<CurrentSchema>),
907    CurrentUser(Box<CurrentUser>),
908    UtcTime(Box<UtcTime>),
909    UtcTimestamp(Box<UtcTimestamp>),
910    Timestamp(Box<TimestampFunc>),
911    DateBin(Box<DateBin>),
912    Datetime(Box<Datetime>),
913    DatetimeAdd(Box<DatetimeAdd>),
914    DatetimeSub(Box<DatetimeSub>),
915    DatetimeDiff(Box<DatetimeDiff>),
916    DatetimeTrunc(Box<DatetimeTrunc>),
917    Dayname(Box<Dayname>),
918    MakeInterval(Box<MakeInterval>),
919    PreviousDay(Box<PreviousDay>),
920    Elt(Box<Elt>),
921    TimestampAdd(Box<TimestampAdd>),
922    TimestampSub(Box<TimestampSub>),
923    TimestampDiff(Box<TimestampDiff>),
924    TimeSlice(Box<TimeSlice>),
925    TimeAdd(Box<TimeAdd>),
926    TimeSub(Box<TimeSub>),
927    TimeDiff(Box<TimeDiff>),
928    TimeTrunc(Box<TimeTrunc>),
929    DateFromParts(Box<DateFromParts>),
930    TimeFromParts(Box<TimeFromParts>),
931    DecodeCase(Box<DecodeCase>),
932    Decrypt(Box<Decrypt>),
933    DecryptRaw(Box<DecryptRaw>),
934    Encode(Box<Encode>),
935    Encrypt(Box<Encrypt>),
936    EncryptRaw(Box<EncryptRaw>),
937    EqualNull(Box<EqualNull>),
938    ToBinary(Box<ToBinary>),
939    Base64DecodeBinary(Box<Base64DecodeBinary>),
940    Base64DecodeString(Box<Base64DecodeString>),
941    Base64Encode(Box<Base64Encode>),
942    TryBase64DecodeBinary(Box<TryBase64DecodeBinary>),
943    TryBase64DecodeString(Box<TryBase64DecodeString>),
944    GapFill(Box<GapFill>),
945    GenerateDateArray(Box<GenerateDateArray>),
946    GenerateTimestampArray(Box<GenerateTimestampArray>),
947    GetExtract(Box<GetExtract>),
948    Getbit(Box<Getbit>),
949    OverflowTruncateBehavior(Box<OverflowTruncateBehavior>),
950    HexEncode(Box<HexEncode>),
951    Compress(Box<Compress>),
952    DecompressBinary(Box<DecompressBinary>),
953    DecompressString(Box<DecompressString>),
954    Xor(Box<Xor>),
955    Nullif(Box<Nullif>),
956    JSON(Box<JSON>),
957    JSONPath(Box<JSONPath>),
958    JSONPathFilter(Box<JSONPathFilter>),
959    JSONPathKey(Box<JSONPathKey>),
960    JSONPathRecursive(Box<JSONPathRecursive>),
961    JSONPathScript(Box<JSONPathScript>),
962    JSONPathSlice(Box<JSONPathSlice>),
963    JSONPathSelector(Box<JSONPathSelector>),
964    JSONPathSubscript(Box<JSONPathSubscript>),
965    JSONPathUnion(Box<JSONPathUnion>),
966    Format(Box<Format>),
967    JSONKeys(Box<JSONKeys>),
968    JSONKeyValue(Box<JSONKeyValue>),
969    JSONKeysAtDepth(Box<JSONKeysAtDepth>),
970    JSONObject(Box<JSONObject>),
971    JSONObjectAgg(Box<JSONObjectAgg>),
972    JSONBObjectAgg(Box<JSONBObjectAgg>),
973    JSONArray(Box<JSONArray>),
974    JSONArrayAgg(Box<JSONArrayAgg>),
975    JSONExists(Box<JSONExists>),
976    JSONColumnDef(Box<JSONColumnDef>),
977    JSONSchema(Box<JSONSchema>),
978    JSONSet(Box<JSONSet>),
979    JSONStripNulls(Box<JSONStripNulls>),
980    JSONValue(Box<JSONValue>),
981    JSONValueArray(Box<JSONValueArray>),
982    JSONRemove(Box<JSONRemove>),
983    JSONTable(Box<JSONTable>),
984    JSONType(Box<JSONType>),
985    ObjectInsert(Box<ObjectInsert>),
986    OpenJSONColumnDef(Box<OpenJSONColumnDef>),
987    OpenJSON(Box<OpenJSON>),
988    JSONBExists(Box<JSONBExists>),
989    JSONBContains(Box<BinaryFunc>),
990    JSONBExtract(Box<BinaryFunc>),
991    JSONCast(Box<JSONCast>),
992    JSONExtract(Box<JSONExtract>),
993    JSONExtractQuote(Box<JSONExtractQuote>),
994    JSONExtractArray(Box<JSONExtractArray>),
995    JSONExtractScalar(Box<JSONExtractScalar>),
996    JSONBExtractScalar(Box<JSONBExtractScalar>),
997    JSONFormat(Box<JSONFormat>),
998    JSONBool(Box<UnaryFunc>),
999    JSONPathRoot(JSONPathRoot),
1000    JSONArrayAppend(Box<JSONArrayAppend>),
1001    JSONArrayContains(Box<JSONArrayContains>),
1002    JSONArrayInsert(Box<JSONArrayInsert>),
1003    ParseJSON(Box<ParseJSON>),
1004    ParseUrl(Box<ParseUrl>),
1005    ParseIp(Box<ParseIp>),
1006    ParseTime(Box<ParseTime>),
1007    ParseDatetime(Box<ParseDatetime>),
1008    Map(Box<Map>),
1009    MapCat(Box<MapCat>),
1010    MapDelete(Box<MapDelete>),
1011    MapInsert(Box<MapInsert>),
1012    MapPick(Box<MapPick>),
1013    ScopeResolution(Box<ScopeResolution>),
1014    Slice(Box<Slice>),
1015    VarMap(Box<VarMap>),
1016    MatchAgainst(Box<MatchAgainst>),
1017    MD5Digest(Box<MD5Digest>),
1018    MD5NumberLower64(Box<UnaryFunc>),
1019    MD5NumberUpper64(Box<UnaryFunc>),
1020    Monthname(Box<Monthname>),
1021    Ntile(Box<Ntile>),
1022    Normalize(Box<Normalize>),
1023    Normal(Box<Normal>),
1024    Predict(Box<Predict>),
1025    MLTranslate(Box<MLTranslate>),
1026    FeaturesAtTime(Box<FeaturesAtTime>),
1027    GenerateEmbedding(Box<GenerateEmbedding>),
1028    MLForecast(Box<MLForecast>),
1029    ModelAttribute(Box<ModelAttribute>),
1030    VectorSearch(Box<VectorSearch>),
1031    Quantile(Box<Quantile>),
1032    ApproxQuantile(Box<ApproxQuantile>),
1033    ApproxPercentileEstimate(Box<ApproxPercentileEstimate>),
1034    Randn(Box<Randn>),
1035    Randstr(Box<Randstr>),
1036    RangeN(Box<RangeN>),
1037    RangeBucket(Box<RangeBucket>),
1038    ReadCSV(Box<ReadCSV>),
1039    ReadParquet(Box<ReadParquet>),
1040    Reduce(Box<Reduce>),
1041    RegexpExtractAll(Box<RegexpExtractAll>),
1042    RegexpILike(Box<RegexpILike>),
1043    RegexpFullMatch(Box<RegexpFullMatch>),
1044    RegexpInstr(Box<RegexpInstr>),
1045    RegexpSplit(Box<RegexpSplit>),
1046    RegexpCount(Box<RegexpCount>),
1047    RegrValx(Box<RegrValx>),
1048    RegrValy(Box<RegrValy>),
1049    RegrAvgy(Box<RegrAvgy>),
1050    RegrAvgx(Box<RegrAvgx>),
1051    RegrCount(Box<RegrCount>),
1052    RegrIntercept(Box<RegrIntercept>),
1053    RegrR2(Box<RegrR2>),
1054    RegrSxx(Box<RegrSxx>),
1055    RegrSxy(Box<RegrSxy>),
1056    RegrSyy(Box<RegrSyy>),
1057    RegrSlope(Box<RegrSlope>),
1058    SafeAdd(Box<SafeAdd>),
1059    SafeDivide(Box<SafeDivide>),
1060    SafeMultiply(Box<SafeMultiply>),
1061    SafeSubtract(Box<SafeSubtract>),
1062    SHA2(Box<SHA2>),
1063    SHA2Digest(Box<SHA2Digest>),
1064    SortArray(Box<SortArray>),
1065    SplitPart(Box<SplitPart>),
1066    SubstringIndex(Box<SubstringIndex>),
1067    StandardHash(Box<StandardHash>),
1068    StrPosition(Box<StrPosition>),
1069    Search(Box<Search>),
1070    SearchIp(Box<SearchIp>),
1071    StrToDate(Box<StrToDate>),
1072    DateStrToDate(Box<UnaryFunc>),
1073    DateToDateStr(Box<UnaryFunc>),
1074    StrToTime(Box<StrToTime>),
1075    StrToUnix(Box<StrToUnix>),
1076    StrToMap(Box<StrToMap>),
1077    NumberToStr(Box<NumberToStr>),
1078    FromBase(Box<FromBase>),
1079    Stuff(Box<Stuff>),
1080    TimeToStr(Box<TimeToStr>),
1081    TimeStrToTime(Box<TimeStrToTime>),
1082    TsOrDsAdd(Box<TsOrDsAdd>),
1083    TsOrDsDiff(Box<TsOrDsDiff>),
1084    TsOrDsToDate(Box<TsOrDsToDate>),
1085    TsOrDsToTime(Box<TsOrDsToTime>),
1086    Unhex(Box<Unhex>),
1087    Uniform(Box<Uniform>),
1088    UnixToStr(Box<UnixToStr>),
1089    UnixToTime(Box<UnixToTime>),
1090    Uuid(Box<Uuid>),
1091    TimestampFromParts(Box<TimestampFromParts>),
1092    TimestampTzFromParts(Box<TimestampTzFromParts>),
1093    Corr(Box<Corr>),
1094    WidthBucket(Box<WidthBucket>),
1095    CovarSamp(Box<CovarSamp>),
1096    CovarPop(Box<CovarPop>),
1097    Week(Box<Week>),
1098    XMLElement(Box<XMLElement>),
1099    XMLGet(Box<XMLGet>),
1100    XMLTable(Box<XMLTable>),
1101    XMLKeyValueOption(Box<XMLKeyValueOption>),
1102    Zipf(Box<Zipf>),
1103    Merge(Box<Merge>),
1104    When(Box<When>),
1105    Whens(Box<Whens>),
1106    NextValueFor(Box<NextValueFor>),
1107    /// RETURN statement (DuckDB stored procedures)
1108    ReturnStmt(Box<Expression>),
1109}
1110
1111impl Expression {
1112    /// Create a `Column` variant, boxing the value automatically.
1113    #[inline]
1114    pub fn boxed_column(col: Column) -> Self {
1115        Expression::Column(Box::new(col))
1116    }
1117
1118    /// Create a `Table` variant, boxing the value automatically.
1119    #[inline]
1120    pub fn boxed_table(t: TableRef) -> Self {
1121        Expression::Table(Box::new(t))
1122    }
1123
1124    /// Returns `true` if this expression is a valid top-level SQL statement.
1125    ///
1126    /// Bare expressions like identifiers, literals, and function calls are not
1127    /// valid statements. This is used by `validate()` to reject inputs like
1128    /// `SELECT scooby dooby doo` which the parser splits into `SELECT scooby AS dooby`
1129    /// plus the bare identifier `doo`.
1130    pub fn is_statement(&self) -> bool {
1131        match self {
1132            // Queries
1133            Expression::Select(_)
1134            | Expression::Union(_)
1135            | Expression::Intersect(_)
1136            | Expression::Except(_)
1137            | Expression::Subquery(_)
1138            | Expression::Values(_)
1139            | Expression::PipeOperator(_)
1140
1141            // DML
1142            | Expression::Insert(_)
1143            | Expression::Update(_)
1144            | Expression::Delete(_)
1145            | Expression::Copy(_)
1146            | Expression::Put(_)
1147            | Expression::Merge(_)
1148
1149            // DDL
1150            | Expression::CreateTable(_)
1151            | Expression::DropTable(_)
1152            | Expression::AlterTable(_)
1153            | Expression::CreateIndex(_)
1154            | Expression::DropIndex(_)
1155            | Expression::CreateView(_)
1156            | Expression::DropView(_)
1157            | Expression::AlterView(_)
1158            | Expression::AlterIndex(_)
1159            | Expression::Truncate(_)
1160            | Expression::TruncateTable(_)
1161            | Expression::CreateSchema(_)
1162            | Expression::DropSchema(_)
1163            | Expression::DropNamespace(_)
1164            | Expression::CreateDatabase(_)
1165            | Expression::DropDatabase(_)
1166            | Expression::CreateFunction(_)
1167            | Expression::DropFunction(_)
1168            | Expression::CreateProcedure(_)
1169            | Expression::DropProcedure(_)
1170            | Expression::CreateSequence(_)
1171            | Expression::DropSequence(_)
1172            | Expression::AlterSequence(_)
1173            | Expression::CreateTrigger(_)
1174            | Expression::DropTrigger(_)
1175            | Expression::CreateType(_)
1176            | Expression::DropType(_)
1177            | Expression::Comment(_)
1178
1179            // Session/Transaction/Control
1180            | Expression::Use(_)
1181            | Expression::Set(_)
1182            | Expression::SetStatement(_)
1183            | Expression::Transaction(_)
1184            | Expression::Commit(_)
1185            | Expression::Rollback(_)
1186            | Expression::Grant(_)
1187            | Expression::Revoke(_)
1188            | Expression::Cache(_)
1189            | Expression::Uncache(_)
1190            | Expression::LoadData(_)
1191            | Expression::Pragma(_)
1192            | Expression::Describe(_)
1193            | Expression::Show(_)
1194            | Expression::Kill(_)
1195            | Expression::Execute(_)
1196            | Expression::Declare(_)
1197            | Expression::Refresh(_)
1198            | Expression::AlterSession(_)
1199            | Expression::LockingStatement(_)
1200
1201            // Analyze
1202            | Expression::Analyze(_)
1203            | Expression::AnalyzeStatistics(_)
1204            | Expression::AnalyzeHistogram(_)
1205            | Expression::AnalyzeSample(_)
1206            | Expression::AnalyzeListChainedRows(_)
1207            | Expression::AnalyzeDelete(_)
1208
1209            // Attach/Detach/Install/Summarize
1210            | Expression::Attach(_)
1211            | Expression::Detach(_)
1212            | Expression::Install(_)
1213            | Expression::Summarize(_)
1214
1215            // Pivot at statement level
1216            | Expression::Pivot(_)
1217            | Expression::Unpivot(_)
1218
1219            // Command (raw/unparsed statements)
1220            | Expression::Command(_)
1221            | Expression::Raw(_)
1222            | Expression::CreateTask(_)
1223
1224            // Return statement
1225            | Expression::ReturnStmt(_) => true,
1226
1227            // Annotated wraps another expression with comments — check inner
1228            Expression::Annotated(a) => a.this.is_statement(),
1229
1230            // Alias at top level can wrap a statement (e.g., parenthesized subquery with alias)
1231            Expression::Alias(a) => a.this.is_statement(),
1232
1233            // Everything else (identifiers, literals, operators, functions, etc.)
1234            _ => false,
1235        }
1236    }
1237
1238    /// Create a literal number expression from an integer.
1239    pub fn number(n: i64) -> Self {
1240        Expression::Literal(Box::new(Literal::Number(n.to_string())))
1241    }
1242
1243    /// Create a single-quoted literal string expression.
1244    pub fn string(s: impl Into<String>) -> Self {
1245        Expression::Literal(Box::new(Literal::String(s.into())))
1246    }
1247
1248    /// Create a literal number expression from a float.
1249    pub fn float(f: f64) -> Self {
1250        Expression::Literal(Box::new(Literal::Number(f.to_string())))
1251    }
1252
1253    /// Get the inferred type annotation, if present.
1254    ///
1255    /// For value-producing expressions with an `inferred_type` field, returns
1256    /// the stored type. For literals and boolean constants, computes the type
1257    /// on the fly from the variant. For DDL/clause expressions, returns `None`.
1258    pub fn inferred_type(&self) -> Option<&DataType> {
1259        match self {
1260            // Structs with inferred_type field
1261            Expression::And(op)
1262            | Expression::Or(op)
1263            | Expression::Add(op)
1264            | Expression::Sub(op)
1265            | Expression::Mul(op)
1266            | Expression::Div(op)
1267            | Expression::Mod(op)
1268            | Expression::Eq(op)
1269            | Expression::Neq(op)
1270            | Expression::Lt(op)
1271            | Expression::Lte(op)
1272            | Expression::Gt(op)
1273            | Expression::Gte(op)
1274            | Expression::Concat(op)
1275            | Expression::BitwiseAnd(op)
1276            | Expression::BitwiseOr(op)
1277            | Expression::BitwiseXor(op)
1278            | Expression::Adjacent(op)
1279            | Expression::TsMatch(op)
1280            | Expression::PropertyEQ(op)
1281            | Expression::ArrayContainsAll(op)
1282            | Expression::ArrayContainedBy(op)
1283            | Expression::ArrayOverlaps(op)
1284            | Expression::JSONBContainsAllTopKeys(op)
1285            | Expression::JSONBContainsAnyTopKeys(op)
1286            | Expression::JSONBDeleteAtPath(op)
1287            | Expression::ExtendsLeft(op)
1288            | Expression::ExtendsRight(op)
1289            | Expression::Is(op)
1290            | Expression::MemberOf(op)
1291            | Expression::Match(op)
1292            | Expression::NullSafeEq(op)
1293            | Expression::NullSafeNeq(op)
1294            | Expression::Glob(op)
1295            | Expression::BitwiseLeftShift(op)
1296            | Expression::BitwiseRightShift(op) => op.inferred_type.as_ref(),
1297
1298            Expression::Not(op) | Expression::Neg(op) | Expression::BitwiseNot(op) => {
1299                op.inferred_type.as_ref()
1300            }
1301
1302            Expression::Like(op) | Expression::ILike(op) => op.inferred_type.as_ref(),
1303
1304            Expression::Cast(c) | Expression::TryCast(c) | Expression::SafeCast(c) => {
1305                c.inferred_type.as_ref()
1306            }
1307
1308            Expression::Column(c) => c.inferred_type.as_ref(),
1309            Expression::Function(f) => f.inferred_type.as_ref(),
1310            Expression::AggregateFunction(f) => f.inferred_type.as_ref(),
1311            Expression::WindowFunction(f) => f.inferred_type.as_ref(),
1312            Expression::Case(c) => c.inferred_type.as_ref(),
1313            Expression::Subquery(s) => s.inferred_type.as_ref(),
1314            Expression::Alias(a) => a.inferred_type.as_ref(),
1315            Expression::IfFunc(f) => f.inferred_type.as_ref(),
1316            Expression::Nvl2(f) => f.inferred_type.as_ref(),
1317            Expression::Count(f) => f.inferred_type.as_ref(),
1318            Expression::GroupConcat(f) => f.inferred_type.as_ref(),
1319            Expression::StringAgg(f) => f.inferred_type.as_ref(),
1320            Expression::ListAgg(f) => f.inferred_type.as_ref(),
1321            Expression::SumIf(f) => f.inferred_type.as_ref(),
1322
1323            // UnaryFunc variants
1324            Expression::Upper(f)
1325            | Expression::Lower(f)
1326            | Expression::Length(f)
1327            | Expression::LTrim(f)
1328            | Expression::RTrim(f)
1329            | Expression::Reverse(f)
1330            | Expression::Abs(f)
1331            | Expression::Sqrt(f)
1332            | Expression::Cbrt(f)
1333            | Expression::Ln(f)
1334            | Expression::Exp(f)
1335            | Expression::Sign(f)
1336            | Expression::Date(f)
1337            | Expression::Time(f)
1338            | Expression::Initcap(f)
1339            | Expression::Ascii(f)
1340            | Expression::Chr(f)
1341            | Expression::Soundex(f)
1342            | Expression::ByteLength(f)
1343            | Expression::Hex(f)
1344            | Expression::LowerHex(f)
1345            | Expression::Unicode(f)
1346            | Expression::Typeof(f)
1347            | Expression::Explode(f)
1348            | Expression::ExplodeOuter(f)
1349            | Expression::MapFromEntries(f)
1350            | Expression::MapKeys(f)
1351            | Expression::MapValues(f)
1352            | Expression::ArrayLength(f)
1353            | Expression::ArraySize(f)
1354            | Expression::Cardinality(f)
1355            | Expression::ArrayReverse(f)
1356            | Expression::ArrayDistinct(f)
1357            | Expression::ArrayFlatten(f)
1358            | Expression::ArrayCompact(f)
1359            | Expression::ToArray(f)
1360            | Expression::JsonArrayLength(f)
1361            | Expression::JsonKeys(f)
1362            | Expression::JsonType(f)
1363            | Expression::ParseJson(f)
1364            | Expression::ToJson(f)
1365            | Expression::Radians(f)
1366            | Expression::Degrees(f)
1367            | Expression::Sin(f)
1368            | Expression::Cos(f)
1369            | Expression::Tan(f)
1370            | Expression::Asin(f)
1371            | Expression::Acos(f)
1372            | Expression::Atan(f)
1373            | Expression::IsNan(f)
1374            | Expression::IsInf(f)
1375            | Expression::Year(f)
1376            | Expression::Month(f)
1377            | Expression::Day(f)
1378            | Expression::Hour(f)
1379            | Expression::Minute(f)
1380            | Expression::Second(f)
1381            | Expression::DayOfWeek(f)
1382            | Expression::DayOfWeekIso(f)
1383            | Expression::DayOfMonth(f)
1384            | Expression::DayOfYear(f)
1385            | Expression::WeekOfYear(f)
1386            | Expression::Quarter(f)
1387            | Expression::Epoch(f)
1388            | Expression::EpochMs(f)
1389            | Expression::BitwiseCount(f)
1390            | Expression::DateFromUnixDate(f)
1391            | Expression::UnixDate(f)
1392            | Expression::UnixSeconds(f)
1393            | Expression::UnixMillis(f)
1394            | Expression::UnixMicros(f)
1395            | Expression::TimeStrToDate(f)
1396            | Expression::DateToDi(f)
1397            | Expression::DiToDate(f)
1398            | Expression::TsOrDiToDi(f)
1399            | Expression::TsOrDsToDatetime(f)
1400            | Expression::TsOrDsToTimestamp(f)
1401            | Expression::YearOfWeek(f)
1402            | Expression::YearOfWeekIso(f)
1403            | Expression::SHA(f)
1404            | Expression::SHA1Digest(f)
1405            | Expression::TimeToUnix(f)
1406            | Expression::TimeStrToUnix(f) => f.inferred_type.as_ref(),
1407
1408            // BinaryFunc variants
1409            Expression::Power(f)
1410            | Expression::NullIf(f)
1411            | Expression::IfNull(f)
1412            | Expression::Nvl(f)
1413            | Expression::Contains(f)
1414            | Expression::StartsWith(f)
1415            | Expression::EndsWith(f)
1416            | Expression::Levenshtein(f)
1417            | Expression::ModFunc(f)
1418            | Expression::IntDiv(f)
1419            | Expression::Atan2(f)
1420            | Expression::AddMonths(f)
1421            | Expression::MonthsBetween(f)
1422            | Expression::NextDay(f)
1423            | Expression::UnixToTimeStr(f)
1424            | Expression::ArrayContains(f)
1425            | Expression::ArrayPosition(f)
1426            | Expression::ArrayAppend(f)
1427            | Expression::ArrayPrepend(f)
1428            | Expression::ArrayUnion(f)
1429            | Expression::ArrayExcept(f)
1430            | Expression::ArrayRemove(f)
1431            | Expression::StarMap(f)
1432            | Expression::MapFromArrays(f)
1433            | Expression::MapContainsKey(f)
1434            | Expression::ElementAt(f)
1435            | Expression::JsonMergePatch(f) => f.inferred_type.as_ref(),
1436
1437            // VarArgFunc variants
1438            Expression::Coalesce(f)
1439            | Expression::Greatest(f)
1440            | Expression::Least(f)
1441            | Expression::ArrayConcat(f)
1442            | Expression::ArrayIntersect(f)
1443            | Expression::ArrayZip(f)
1444            | Expression::MapConcat(f)
1445            | Expression::JsonArray(f) => f.inferred_type.as_ref(),
1446
1447            // AggFunc variants
1448            Expression::Sum(f)
1449            | Expression::Avg(f)
1450            | Expression::Min(f)
1451            | Expression::Max(f)
1452            | Expression::ArrayAgg(f)
1453            | Expression::CountIf(f)
1454            | Expression::Stddev(f)
1455            | Expression::StddevPop(f)
1456            | Expression::StddevSamp(f)
1457            | Expression::Variance(f)
1458            | Expression::VarPop(f)
1459            | Expression::VarSamp(f)
1460            | Expression::Median(f)
1461            | Expression::Mode(f)
1462            | Expression::First(f)
1463            | Expression::Last(f)
1464            | Expression::AnyValue(f)
1465            | Expression::ApproxDistinct(f)
1466            | Expression::ApproxCountDistinct(f)
1467            | Expression::LogicalAnd(f)
1468            | Expression::LogicalOr(f)
1469            | Expression::Skewness(f)
1470            | Expression::ArrayConcatAgg(f)
1471            | Expression::ArrayUniqueAgg(f)
1472            | Expression::BoolXorAgg(f)
1473            | Expression::BitwiseAndAgg(f)
1474            | Expression::BitwiseOrAgg(f)
1475            | Expression::BitwiseXorAgg(f) => f.inferred_type.as_ref(),
1476
1477            // Everything else: no inferred_type field
1478            _ => None,
1479        }
1480    }
1481
1482    /// Set the inferred type annotation on this expression.
1483    ///
1484    /// Only has an effect on value-producing expressions with an `inferred_type`
1485    /// field. For other expression types, this is a no-op.
1486    pub fn set_inferred_type(&mut self, dt: DataType) {
1487        match self {
1488            Expression::And(op)
1489            | Expression::Or(op)
1490            | Expression::Add(op)
1491            | Expression::Sub(op)
1492            | Expression::Mul(op)
1493            | Expression::Div(op)
1494            | Expression::Mod(op)
1495            | Expression::Eq(op)
1496            | Expression::Neq(op)
1497            | Expression::Lt(op)
1498            | Expression::Lte(op)
1499            | Expression::Gt(op)
1500            | Expression::Gte(op)
1501            | Expression::Concat(op)
1502            | Expression::BitwiseAnd(op)
1503            | Expression::BitwiseOr(op)
1504            | Expression::BitwiseXor(op)
1505            | Expression::Adjacent(op)
1506            | Expression::TsMatch(op)
1507            | Expression::PropertyEQ(op)
1508            | Expression::ArrayContainsAll(op)
1509            | Expression::ArrayContainedBy(op)
1510            | Expression::ArrayOverlaps(op)
1511            | Expression::JSONBContainsAllTopKeys(op)
1512            | Expression::JSONBContainsAnyTopKeys(op)
1513            | Expression::JSONBDeleteAtPath(op)
1514            | Expression::ExtendsLeft(op)
1515            | Expression::ExtendsRight(op)
1516            | Expression::Is(op)
1517            | Expression::MemberOf(op)
1518            | Expression::Match(op)
1519            | Expression::NullSafeEq(op)
1520            | Expression::NullSafeNeq(op)
1521            | Expression::Glob(op)
1522            | Expression::BitwiseLeftShift(op)
1523            | Expression::BitwiseRightShift(op) => op.inferred_type = Some(dt),
1524
1525            Expression::Not(op) | Expression::Neg(op) | Expression::BitwiseNot(op) => {
1526                op.inferred_type = Some(dt)
1527            }
1528
1529            Expression::Like(op) | Expression::ILike(op) => op.inferred_type = Some(dt),
1530
1531            Expression::Cast(c) | Expression::TryCast(c) | Expression::SafeCast(c) => {
1532                c.inferred_type = Some(dt)
1533            }
1534
1535            Expression::Column(c) => c.inferred_type = Some(dt),
1536            Expression::Function(f) => f.inferred_type = Some(dt),
1537            Expression::AggregateFunction(f) => f.inferred_type = Some(dt),
1538            Expression::WindowFunction(f) => f.inferred_type = Some(dt),
1539            Expression::Case(c) => c.inferred_type = Some(dt),
1540            Expression::Subquery(s) => s.inferred_type = Some(dt),
1541            Expression::Alias(a) => a.inferred_type = Some(dt),
1542            Expression::IfFunc(f) => f.inferred_type = Some(dt),
1543            Expression::Nvl2(f) => f.inferred_type = Some(dt),
1544            Expression::Count(f) => f.inferred_type = Some(dt),
1545            Expression::GroupConcat(f) => f.inferred_type = Some(dt),
1546            Expression::StringAgg(f) => f.inferred_type = Some(dt),
1547            Expression::ListAgg(f) => f.inferred_type = Some(dt),
1548            Expression::SumIf(f) => f.inferred_type = Some(dt),
1549
1550            // UnaryFunc variants
1551            Expression::Upper(f)
1552            | Expression::Lower(f)
1553            | Expression::Length(f)
1554            | Expression::LTrim(f)
1555            | Expression::RTrim(f)
1556            | Expression::Reverse(f)
1557            | Expression::Abs(f)
1558            | Expression::Sqrt(f)
1559            | Expression::Cbrt(f)
1560            | Expression::Ln(f)
1561            | Expression::Exp(f)
1562            | Expression::Sign(f)
1563            | Expression::Date(f)
1564            | Expression::Time(f)
1565            | Expression::Initcap(f)
1566            | Expression::Ascii(f)
1567            | Expression::Chr(f)
1568            | Expression::Soundex(f)
1569            | Expression::ByteLength(f)
1570            | Expression::Hex(f)
1571            | Expression::LowerHex(f)
1572            | Expression::Unicode(f)
1573            | Expression::Typeof(f)
1574            | Expression::Explode(f)
1575            | Expression::ExplodeOuter(f)
1576            | Expression::MapFromEntries(f)
1577            | Expression::MapKeys(f)
1578            | Expression::MapValues(f)
1579            | Expression::ArrayLength(f)
1580            | Expression::ArraySize(f)
1581            | Expression::Cardinality(f)
1582            | Expression::ArrayReverse(f)
1583            | Expression::ArrayDistinct(f)
1584            | Expression::ArrayFlatten(f)
1585            | Expression::ArrayCompact(f)
1586            | Expression::ToArray(f)
1587            | Expression::JsonArrayLength(f)
1588            | Expression::JsonKeys(f)
1589            | Expression::JsonType(f)
1590            | Expression::ParseJson(f)
1591            | Expression::ToJson(f)
1592            | Expression::Radians(f)
1593            | Expression::Degrees(f)
1594            | Expression::Sin(f)
1595            | Expression::Cos(f)
1596            | Expression::Tan(f)
1597            | Expression::Asin(f)
1598            | Expression::Acos(f)
1599            | Expression::Atan(f)
1600            | Expression::IsNan(f)
1601            | Expression::IsInf(f)
1602            | Expression::Year(f)
1603            | Expression::Month(f)
1604            | Expression::Day(f)
1605            | Expression::Hour(f)
1606            | Expression::Minute(f)
1607            | Expression::Second(f)
1608            | Expression::DayOfWeek(f)
1609            | Expression::DayOfWeekIso(f)
1610            | Expression::DayOfMonth(f)
1611            | Expression::DayOfYear(f)
1612            | Expression::WeekOfYear(f)
1613            | Expression::Quarter(f)
1614            | Expression::Epoch(f)
1615            | Expression::EpochMs(f)
1616            | Expression::BitwiseCount(f)
1617            | Expression::DateFromUnixDate(f)
1618            | Expression::UnixDate(f)
1619            | Expression::UnixSeconds(f)
1620            | Expression::UnixMillis(f)
1621            | Expression::UnixMicros(f)
1622            | Expression::TimeStrToDate(f)
1623            | Expression::DateToDi(f)
1624            | Expression::DiToDate(f)
1625            | Expression::TsOrDiToDi(f)
1626            | Expression::TsOrDsToDatetime(f)
1627            | Expression::TsOrDsToTimestamp(f)
1628            | Expression::YearOfWeek(f)
1629            | Expression::YearOfWeekIso(f)
1630            | Expression::SHA(f)
1631            | Expression::SHA1Digest(f)
1632            | Expression::TimeToUnix(f)
1633            | Expression::TimeStrToUnix(f) => f.inferred_type = Some(dt),
1634
1635            // BinaryFunc variants
1636            Expression::Power(f)
1637            | Expression::NullIf(f)
1638            | Expression::IfNull(f)
1639            | Expression::Nvl(f)
1640            | Expression::Contains(f)
1641            | Expression::StartsWith(f)
1642            | Expression::EndsWith(f)
1643            | Expression::Levenshtein(f)
1644            | Expression::ModFunc(f)
1645            | Expression::IntDiv(f)
1646            | Expression::Atan2(f)
1647            | Expression::AddMonths(f)
1648            | Expression::MonthsBetween(f)
1649            | Expression::NextDay(f)
1650            | Expression::UnixToTimeStr(f)
1651            | Expression::ArrayContains(f)
1652            | Expression::ArrayPosition(f)
1653            | Expression::ArrayAppend(f)
1654            | Expression::ArrayPrepend(f)
1655            | Expression::ArrayUnion(f)
1656            | Expression::ArrayExcept(f)
1657            | Expression::ArrayRemove(f)
1658            | Expression::StarMap(f)
1659            | Expression::MapFromArrays(f)
1660            | Expression::MapContainsKey(f)
1661            | Expression::ElementAt(f)
1662            | Expression::JsonMergePatch(f) => f.inferred_type = Some(dt),
1663
1664            // VarArgFunc variants
1665            Expression::Coalesce(f)
1666            | Expression::Greatest(f)
1667            | Expression::Least(f)
1668            | Expression::ArrayConcat(f)
1669            | Expression::ArrayIntersect(f)
1670            | Expression::ArrayZip(f)
1671            | Expression::MapConcat(f)
1672            | Expression::JsonArray(f) => f.inferred_type = Some(dt),
1673
1674            // AggFunc variants
1675            Expression::Sum(f)
1676            | Expression::Avg(f)
1677            | Expression::Min(f)
1678            | Expression::Max(f)
1679            | Expression::ArrayAgg(f)
1680            | Expression::CountIf(f)
1681            | Expression::Stddev(f)
1682            | Expression::StddevPop(f)
1683            | Expression::StddevSamp(f)
1684            | Expression::Variance(f)
1685            | Expression::VarPop(f)
1686            | Expression::VarSamp(f)
1687            | Expression::Median(f)
1688            | Expression::Mode(f)
1689            | Expression::First(f)
1690            | Expression::Last(f)
1691            | Expression::AnyValue(f)
1692            | Expression::ApproxDistinct(f)
1693            | Expression::ApproxCountDistinct(f)
1694            | Expression::LogicalAnd(f)
1695            | Expression::LogicalOr(f)
1696            | Expression::Skewness(f)
1697            | Expression::ArrayConcatAgg(f)
1698            | Expression::ArrayUniqueAgg(f)
1699            | Expression::BoolXorAgg(f)
1700            | Expression::BitwiseAndAgg(f)
1701            | Expression::BitwiseOrAgg(f)
1702            | Expression::BitwiseXorAgg(f) => f.inferred_type = Some(dt),
1703
1704            // Expressions without inferred_type field - no-op
1705            _ => {}
1706        }
1707    }
1708
1709    /// Create an unqualified column reference (e.g. `name`).
1710    pub fn column(name: impl Into<String>) -> Self {
1711        Expression::Column(Box::new(Column {
1712            name: Identifier::new(name),
1713            table: None,
1714            join_mark: false,
1715            trailing_comments: Vec::new(),
1716            span: None,
1717            inferred_type: None,
1718        }))
1719    }
1720
1721    /// Create a qualified column reference (`table.column`).
1722    pub fn qualified_column(table: impl Into<String>, column: impl Into<String>) -> Self {
1723        Expression::Column(Box::new(Column {
1724            name: Identifier::new(column),
1725            table: Some(Identifier::new(table)),
1726            join_mark: false,
1727            trailing_comments: Vec::new(),
1728            span: None,
1729            inferred_type: None,
1730        }))
1731    }
1732
1733    /// Create a bare identifier expression (not a column reference).
1734    pub fn identifier(name: impl Into<String>) -> Self {
1735        Expression::Identifier(Identifier::new(name))
1736    }
1737
1738    /// Create a NULL expression
1739    pub fn null() -> Self {
1740        Expression::Null(Null)
1741    }
1742
1743    /// Create a TRUE expression
1744    pub fn true_() -> Self {
1745        Expression::Boolean(BooleanLiteral { value: true })
1746    }
1747
1748    /// Create a FALSE expression
1749    pub fn false_() -> Self {
1750        Expression::Boolean(BooleanLiteral { value: false })
1751    }
1752
1753    /// Create a wildcard star (`*`) expression with no EXCEPT/REPLACE/RENAME modifiers.
1754    pub fn star() -> Self {
1755        Expression::Star(Star {
1756            table: None,
1757            except: None,
1758            replace: None,
1759            rename: None,
1760            trailing_comments: Vec::new(),
1761            span: None,
1762        })
1763    }
1764
1765    /// Wrap this expression in an `AS` alias (e.g. `expr AS name`).
1766    pub fn alias(self, name: impl Into<String>) -> Self {
1767        Expression::Alias(Box::new(Alias::new(self, Identifier::new(name))))
1768    }
1769
1770    /// Check if this is a SELECT expression
1771    pub fn is_select(&self) -> bool {
1772        matches!(self, Expression::Select(_))
1773    }
1774
1775    /// Try to get as a Select
1776    pub fn as_select(&self) -> Option<&Select> {
1777        match self {
1778            Expression::Select(s) => Some(s),
1779            _ => None,
1780        }
1781    }
1782
1783    /// Try to get as a mutable Select
1784    pub fn as_select_mut(&mut self) -> Option<&mut Select> {
1785        match self {
1786            Expression::Select(s) => Some(s),
1787            _ => None,
1788        }
1789    }
1790
1791    /// Generate a SQL string for this expression using the generic (dialect-agnostic) generator.
1792    ///
1793    /// Returns an empty string if generation fails. For dialect-specific output,
1794    /// use [`sql_for()`](Self::sql_for) instead.
1795    pub fn sql(&self) -> String {
1796        crate::generator::Generator::sql(self).unwrap_or_default()
1797    }
1798
1799    /// Generate a SQL string for this expression targeting a specific dialect.
1800    ///
1801    /// Dialect-specific rules (identifier quoting, function names, type mappings,
1802    /// syntax variations) are applied automatically.  Returns an empty string if
1803    /// generation fails.
1804    pub fn sql_for(&self, dialect: crate::dialects::DialectType) -> String {
1805        crate::generate(self, dialect).unwrap_or_default()
1806    }
1807}
1808
1809// === Python API accessor methods ===
1810
1811impl Expression {
1812    /// Returns the serde-compatible snake_case variant name without serialization.
1813    /// This is much faster than serializing to JSON and extracting the key.
1814    pub fn variant_name(&self) -> &'static str {
1815        match self {
1816            Expression::Literal(_) => "literal",
1817            Expression::Boolean(_) => "boolean",
1818            Expression::Null(_) => "null",
1819            Expression::Identifier(_) => "identifier",
1820            Expression::Column(_) => "column",
1821            Expression::Table(_) => "table",
1822            Expression::Star(_) => "star",
1823            Expression::BracedWildcard(_) => "braced_wildcard",
1824            Expression::Select(_) => "select",
1825            Expression::Union(_) => "union",
1826            Expression::Intersect(_) => "intersect",
1827            Expression::Except(_) => "except",
1828            Expression::Subquery(_) => "subquery",
1829            Expression::PipeOperator(_) => "pipe_operator",
1830            Expression::Pivot(_) => "pivot",
1831            Expression::PivotAlias(_) => "pivot_alias",
1832            Expression::Unpivot(_) => "unpivot",
1833            Expression::Values(_) => "values",
1834            Expression::PreWhere(_) => "pre_where",
1835            Expression::Stream(_) => "stream",
1836            Expression::UsingData(_) => "using_data",
1837            Expression::XmlNamespace(_) => "xml_namespace",
1838            Expression::Insert(_) => "insert",
1839            Expression::Update(_) => "update",
1840            Expression::Delete(_) => "delete",
1841            Expression::Copy(_) => "copy",
1842            Expression::Put(_) => "put",
1843            Expression::StageReference(_) => "stage_reference",
1844            Expression::Alias(_) => "alias",
1845            Expression::Cast(_) => "cast",
1846            Expression::Collation(_) => "collation",
1847            Expression::Case(_) => "case",
1848            Expression::And(_) => "and",
1849            Expression::Or(_) => "or",
1850            Expression::Add(_) => "add",
1851            Expression::Sub(_) => "sub",
1852            Expression::Mul(_) => "mul",
1853            Expression::Div(_) => "div",
1854            Expression::Mod(_) => "mod",
1855            Expression::Eq(_) => "eq",
1856            Expression::Neq(_) => "neq",
1857            Expression::Lt(_) => "lt",
1858            Expression::Lte(_) => "lte",
1859            Expression::Gt(_) => "gt",
1860            Expression::Gte(_) => "gte",
1861            Expression::Like(_) => "like",
1862            Expression::ILike(_) => "i_like",
1863            Expression::Match(_) => "match",
1864            Expression::BitwiseAnd(_) => "bitwise_and",
1865            Expression::BitwiseOr(_) => "bitwise_or",
1866            Expression::BitwiseXor(_) => "bitwise_xor",
1867            Expression::Concat(_) => "concat",
1868            Expression::Adjacent(_) => "adjacent",
1869            Expression::TsMatch(_) => "ts_match",
1870            Expression::PropertyEQ(_) => "property_e_q",
1871            Expression::ArrayContainsAll(_) => "array_contains_all",
1872            Expression::ArrayContainedBy(_) => "array_contained_by",
1873            Expression::ArrayOverlaps(_) => "array_overlaps",
1874            Expression::JSONBContainsAllTopKeys(_) => "j_s_o_n_b_contains_all_top_keys",
1875            Expression::JSONBContainsAnyTopKeys(_) => "j_s_o_n_b_contains_any_top_keys",
1876            Expression::JSONBDeleteAtPath(_) => "j_s_o_n_b_delete_at_path",
1877            Expression::ExtendsLeft(_) => "extends_left",
1878            Expression::ExtendsRight(_) => "extends_right",
1879            Expression::Not(_) => "not",
1880            Expression::Neg(_) => "neg",
1881            Expression::BitwiseNot(_) => "bitwise_not",
1882            Expression::In(_) => "in",
1883            Expression::Between(_) => "between",
1884            Expression::IsNull(_) => "is_null",
1885            Expression::IsTrue(_) => "is_true",
1886            Expression::IsFalse(_) => "is_false",
1887            Expression::IsJson(_) => "is_json",
1888            Expression::Is(_) => "is",
1889            Expression::Exists(_) => "exists",
1890            Expression::MemberOf(_) => "member_of",
1891            Expression::Function(_) => "function",
1892            Expression::AggregateFunction(_) => "aggregate_function",
1893            Expression::WindowFunction(_) => "window_function",
1894            Expression::From(_) => "from",
1895            Expression::Join(_) => "join",
1896            Expression::JoinedTable(_) => "joined_table",
1897            Expression::Where(_) => "where",
1898            Expression::GroupBy(_) => "group_by",
1899            Expression::Having(_) => "having",
1900            Expression::OrderBy(_) => "order_by",
1901            Expression::Limit(_) => "limit",
1902            Expression::Offset(_) => "offset",
1903            Expression::Qualify(_) => "qualify",
1904            Expression::With(_) => "with",
1905            Expression::Cte(_) => "cte",
1906            Expression::DistributeBy(_) => "distribute_by",
1907            Expression::ClusterBy(_) => "cluster_by",
1908            Expression::SortBy(_) => "sort_by",
1909            Expression::LateralView(_) => "lateral_view",
1910            Expression::Hint(_) => "hint",
1911            Expression::Pseudocolumn(_) => "pseudocolumn",
1912            Expression::Connect(_) => "connect",
1913            Expression::Prior(_) => "prior",
1914            Expression::ConnectByRoot(_) => "connect_by_root",
1915            Expression::MatchRecognize(_) => "match_recognize",
1916            Expression::Ordered(_) => "ordered",
1917            Expression::Window(_) => "window",
1918            Expression::Over(_) => "over",
1919            Expression::WithinGroup(_) => "within_group",
1920            Expression::DataType(_) => "data_type",
1921            Expression::Array(_) => "array",
1922            Expression::Struct(_) => "struct",
1923            Expression::Tuple(_) => "tuple",
1924            Expression::Interval(_) => "interval",
1925            Expression::ConcatWs(_) => "concat_ws",
1926            Expression::Substring(_) => "substring",
1927            Expression::Upper(_) => "upper",
1928            Expression::Lower(_) => "lower",
1929            Expression::Length(_) => "length",
1930            Expression::Trim(_) => "trim",
1931            Expression::LTrim(_) => "l_trim",
1932            Expression::RTrim(_) => "r_trim",
1933            Expression::Replace(_) => "replace",
1934            Expression::Reverse(_) => "reverse",
1935            Expression::Left(_) => "left",
1936            Expression::Right(_) => "right",
1937            Expression::Repeat(_) => "repeat",
1938            Expression::Lpad(_) => "lpad",
1939            Expression::Rpad(_) => "rpad",
1940            Expression::Split(_) => "split",
1941            Expression::RegexpLike(_) => "regexp_like",
1942            Expression::RegexpReplace(_) => "regexp_replace",
1943            Expression::RegexpExtract(_) => "regexp_extract",
1944            Expression::Overlay(_) => "overlay",
1945            Expression::Abs(_) => "abs",
1946            Expression::Round(_) => "round",
1947            Expression::Floor(_) => "floor",
1948            Expression::Ceil(_) => "ceil",
1949            Expression::Power(_) => "power",
1950            Expression::Sqrt(_) => "sqrt",
1951            Expression::Cbrt(_) => "cbrt",
1952            Expression::Ln(_) => "ln",
1953            Expression::Log(_) => "log",
1954            Expression::Exp(_) => "exp",
1955            Expression::Sign(_) => "sign",
1956            Expression::Greatest(_) => "greatest",
1957            Expression::Least(_) => "least",
1958            Expression::CurrentDate(_) => "current_date",
1959            Expression::CurrentTime(_) => "current_time",
1960            Expression::CurrentTimestamp(_) => "current_timestamp",
1961            Expression::CurrentTimestampLTZ(_) => "current_timestamp_l_t_z",
1962            Expression::AtTimeZone(_) => "at_time_zone",
1963            Expression::DateAdd(_) => "date_add",
1964            Expression::DateSub(_) => "date_sub",
1965            Expression::DateDiff(_) => "date_diff",
1966            Expression::DateTrunc(_) => "date_trunc",
1967            Expression::Extract(_) => "extract",
1968            Expression::ToDate(_) => "to_date",
1969            Expression::ToTimestamp(_) => "to_timestamp",
1970            Expression::Date(_) => "date",
1971            Expression::Time(_) => "time",
1972            Expression::DateFromUnixDate(_) => "date_from_unix_date",
1973            Expression::UnixDate(_) => "unix_date",
1974            Expression::UnixSeconds(_) => "unix_seconds",
1975            Expression::UnixMillis(_) => "unix_millis",
1976            Expression::UnixMicros(_) => "unix_micros",
1977            Expression::UnixToTimeStr(_) => "unix_to_time_str",
1978            Expression::TimeStrToDate(_) => "time_str_to_date",
1979            Expression::DateToDi(_) => "date_to_di",
1980            Expression::DiToDate(_) => "di_to_date",
1981            Expression::TsOrDiToDi(_) => "ts_or_di_to_di",
1982            Expression::TsOrDsToDatetime(_) => "ts_or_ds_to_datetime",
1983            Expression::TsOrDsToTimestamp(_) => "ts_or_ds_to_timestamp",
1984            Expression::YearOfWeek(_) => "year_of_week",
1985            Expression::YearOfWeekIso(_) => "year_of_week_iso",
1986            Expression::Coalesce(_) => "coalesce",
1987            Expression::NullIf(_) => "null_if",
1988            Expression::IfFunc(_) => "if_func",
1989            Expression::IfNull(_) => "if_null",
1990            Expression::Nvl(_) => "nvl",
1991            Expression::Nvl2(_) => "nvl2",
1992            Expression::TryCast(_) => "try_cast",
1993            Expression::SafeCast(_) => "safe_cast",
1994            Expression::Count(_) => "count",
1995            Expression::Sum(_) => "sum",
1996            Expression::Avg(_) => "avg",
1997            Expression::Min(_) => "min",
1998            Expression::Max(_) => "max",
1999            Expression::GroupConcat(_) => "group_concat",
2000            Expression::StringAgg(_) => "string_agg",
2001            Expression::ListAgg(_) => "list_agg",
2002            Expression::ArrayAgg(_) => "array_agg",
2003            Expression::CountIf(_) => "count_if",
2004            Expression::SumIf(_) => "sum_if",
2005            Expression::Stddev(_) => "stddev",
2006            Expression::StddevPop(_) => "stddev_pop",
2007            Expression::StddevSamp(_) => "stddev_samp",
2008            Expression::Variance(_) => "variance",
2009            Expression::VarPop(_) => "var_pop",
2010            Expression::VarSamp(_) => "var_samp",
2011            Expression::Median(_) => "median",
2012            Expression::Mode(_) => "mode",
2013            Expression::First(_) => "first",
2014            Expression::Last(_) => "last",
2015            Expression::AnyValue(_) => "any_value",
2016            Expression::ApproxDistinct(_) => "approx_distinct",
2017            Expression::ApproxCountDistinct(_) => "approx_count_distinct",
2018            Expression::ApproxPercentile(_) => "approx_percentile",
2019            Expression::Percentile(_) => "percentile",
2020            Expression::LogicalAnd(_) => "logical_and",
2021            Expression::LogicalOr(_) => "logical_or",
2022            Expression::Skewness(_) => "skewness",
2023            Expression::BitwiseCount(_) => "bitwise_count",
2024            Expression::ArrayConcatAgg(_) => "array_concat_agg",
2025            Expression::ArrayUniqueAgg(_) => "array_unique_agg",
2026            Expression::BoolXorAgg(_) => "bool_xor_agg",
2027            Expression::RowNumber(_) => "row_number",
2028            Expression::Rank(_) => "rank",
2029            Expression::DenseRank(_) => "dense_rank",
2030            Expression::NTile(_) => "n_tile",
2031            Expression::Lead(_) => "lead",
2032            Expression::Lag(_) => "lag",
2033            Expression::FirstValue(_) => "first_value",
2034            Expression::LastValue(_) => "last_value",
2035            Expression::NthValue(_) => "nth_value",
2036            Expression::PercentRank(_) => "percent_rank",
2037            Expression::CumeDist(_) => "cume_dist",
2038            Expression::PercentileCont(_) => "percentile_cont",
2039            Expression::PercentileDisc(_) => "percentile_disc",
2040            Expression::Contains(_) => "contains",
2041            Expression::StartsWith(_) => "starts_with",
2042            Expression::EndsWith(_) => "ends_with",
2043            Expression::Position(_) => "position",
2044            Expression::Initcap(_) => "initcap",
2045            Expression::Ascii(_) => "ascii",
2046            Expression::Chr(_) => "chr",
2047            Expression::CharFunc(_) => "char_func",
2048            Expression::Soundex(_) => "soundex",
2049            Expression::Levenshtein(_) => "levenshtein",
2050            Expression::ByteLength(_) => "byte_length",
2051            Expression::Hex(_) => "hex",
2052            Expression::LowerHex(_) => "lower_hex",
2053            Expression::Unicode(_) => "unicode",
2054            Expression::ModFunc(_) => "mod_func",
2055            Expression::Random(_) => "random",
2056            Expression::Rand(_) => "rand",
2057            Expression::TruncFunc(_) => "trunc_func",
2058            Expression::Pi(_) => "pi",
2059            Expression::Radians(_) => "radians",
2060            Expression::Degrees(_) => "degrees",
2061            Expression::Sin(_) => "sin",
2062            Expression::Cos(_) => "cos",
2063            Expression::Tan(_) => "tan",
2064            Expression::Asin(_) => "asin",
2065            Expression::Acos(_) => "acos",
2066            Expression::Atan(_) => "atan",
2067            Expression::Atan2(_) => "atan2",
2068            Expression::IsNan(_) => "is_nan",
2069            Expression::IsInf(_) => "is_inf",
2070            Expression::IntDiv(_) => "int_div",
2071            Expression::Decode(_) => "decode",
2072            Expression::DateFormat(_) => "date_format",
2073            Expression::FormatDate(_) => "format_date",
2074            Expression::Year(_) => "year",
2075            Expression::Month(_) => "month",
2076            Expression::Day(_) => "day",
2077            Expression::Hour(_) => "hour",
2078            Expression::Minute(_) => "minute",
2079            Expression::Second(_) => "second",
2080            Expression::DayOfWeek(_) => "day_of_week",
2081            Expression::DayOfWeekIso(_) => "day_of_week_iso",
2082            Expression::DayOfMonth(_) => "day_of_month",
2083            Expression::DayOfYear(_) => "day_of_year",
2084            Expression::WeekOfYear(_) => "week_of_year",
2085            Expression::Quarter(_) => "quarter",
2086            Expression::AddMonths(_) => "add_months",
2087            Expression::MonthsBetween(_) => "months_between",
2088            Expression::LastDay(_) => "last_day",
2089            Expression::NextDay(_) => "next_day",
2090            Expression::Epoch(_) => "epoch",
2091            Expression::EpochMs(_) => "epoch_ms",
2092            Expression::FromUnixtime(_) => "from_unixtime",
2093            Expression::UnixTimestamp(_) => "unix_timestamp",
2094            Expression::MakeDate(_) => "make_date",
2095            Expression::MakeTimestamp(_) => "make_timestamp",
2096            Expression::TimestampTrunc(_) => "timestamp_trunc",
2097            Expression::TimeStrToUnix(_) => "time_str_to_unix",
2098            Expression::SessionUser(_) => "session_user",
2099            Expression::SHA(_) => "s_h_a",
2100            Expression::SHA1Digest(_) => "s_h_a1_digest",
2101            Expression::TimeToUnix(_) => "time_to_unix",
2102            Expression::ArrayFunc(_) => "array_func",
2103            Expression::ArrayLength(_) => "array_length",
2104            Expression::ArraySize(_) => "array_size",
2105            Expression::Cardinality(_) => "cardinality",
2106            Expression::ArrayContains(_) => "array_contains",
2107            Expression::ArrayPosition(_) => "array_position",
2108            Expression::ArrayAppend(_) => "array_append",
2109            Expression::ArrayPrepend(_) => "array_prepend",
2110            Expression::ArrayConcat(_) => "array_concat",
2111            Expression::ArraySort(_) => "array_sort",
2112            Expression::ArrayReverse(_) => "array_reverse",
2113            Expression::ArrayDistinct(_) => "array_distinct",
2114            Expression::ArrayJoin(_) => "array_join",
2115            Expression::ArrayToString(_) => "array_to_string",
2116            Expression::Unnest(_) => "unnest",
2117            Expression::Explode(_) => "explode",
2118            Expression::ExplodeOuter(_) => "explode_outer",
2119            Expression::ArrayFilter(_) => "array_filter",
2120            Expression::ArrayTransform(_) => "array_transform",
2121            Expression::ArrayFlatten(_) => "array_flatten",
2122            Expression::ArrayCompact(_) => "array_compact",
2123            Expression::ArrayIntersect(_) => "array_intersect",
2124            Expression::ArrayUnion(_) => "array_union",
2125            Expression::ArrayExcept(_) => "array_except",
2126            Expression::ArrayRemove(_) => "array_remove",
2127            Expression::ArrayZip(_) => "array_zip",
2128            Expression::Sequence(_) => "sequence",
2129            Expression::Generate(_) => "generate",
2130            Expression::ExplodingGenerateSeries(_) => "exploding_generate_series",
2131            Expression::ToArray(_) => "to_array",
2132            Expression::StarMap(_) => "star_map",
2133            Expression::StructFunc(_) => "struct_func",
2134            Expression::StructExtract(_) => "struct_extract",
2135            Expression::NamedStruct(_) => "named_struct",
2136            Expression::MapFunc(_) => "map_func",
2137            Expression::MapFromEntries(_) => "map_from_entries",
2138            Expression::MapFromArrays(_) => "map_from_arrays",
2139            Expression::MapKeys(_) => "map_keys",
2140            Expression::MapValues(_) => "map_values",
2141            Expression::MapContainsKey(_) => "map_contains_key",
2142            Expression::MapConcat(_) => "map_concat",
2143            Expression::ElementAt(_) => "element_at",
2144            Expression::TransformKeys(_) => "transform_keys",
2145            Expression::TransformValues(_) => "transform_values",
2146            Expression::FunctionEmits(_) => "function_emits",
2147            Expression::JsonExtract(_) => "json_extract",
2148            Expression::JsonExtractScalar(_) => "json_extract_scalar",
2149            Expression::JsonExtractPath(_) => "json_extract_path",
2150            Expression::JsonArray(_) => "json_array",
2151            Expression::JsonObject(_) => "json_object",
2152            Expression::JsonQuery(_) => "json_query",
2153            Expression::JsonValue(_) => "json_value",
2154            Expression::JsonArrayLength(_) => "json_array_length",
2155            Expression::JsonKeys(_) => "json_keys",
2156            Expression::JsonType(_) => "json_type",
2157            Expression::ParseJson(_) => "parse_json",
2158            Expression::ToJson(_) => "to_json",
2159            Expression::JsonSet(_) => "json_set",
2160            Expression::JsonInsert(_) => "json_insert",
2161            Expression::JsonRemove(_) => "json_remove",
2162            Expression::JsonMergePatch(_) => "json_merge_patch",
2163            Expression::JsonArrayAgg(_) => "json_array_agg",
2164            Expression::JsonObjectAgg(_) => "json_object_agg",
2165            Expression::Convert(_) => "convert",
2166            Expression::Typeof(_) => "typeof",
2167            Expression::Lambda(_) => "lambda",
2168            Expression::Parameter(_) => "parameter",
2169            Expression::Placeholder(_) => "placeholder",
2170            Expression::NamedArgument(_) => "named_argument",
2171            Expression::TableArgument(_) => "table_argument",
2172            Expression::SqlComment(_) => "sql_comment",
2173            Expression::NullSafeEq(_) => "null_safe_eq",
2174            Expression::NullSafeNeq(_) => "null_safe_neq",
2175            Expression::Glob(_) => "glob",
2176            Expression::SimilarTo(_) => "similar_to",
2177            Expression::Any(_) => "any",
2178            Expression::All(_) => "all",
2179            Expression::Overlaps(_) => "overlaps",
2180            Expression::BitwiseLeftShift(_) => "bitwise_left_shift",
2181            Expression::BitwiseRightShift(_) => "bitwise_right_shift",
2182            Expression::BitwiseAndAgg(_) => "bitwise_and_agg",
2183            Expression::BitwiseOrAgg(_) => "bitwise_or_agg",
2184            Expression::BitwiseXorAgg(_) => "bitwise_xor_agg",
2185            Expression::Subscript(_) => "subscript",
2186            Expression::Dot(_) => "dot",
2187            Expression::MethodCall(_) => "method_call",
2188            Expression::ArraySlice(_) => "array_slice",
2189            Expression::CreateTable(_) => "create_table",
2190            Expression::DropTable(_) => "drop_table",
2191            Expression::AlterTable(_) => "alter_table",
2192            Expression::CreateIndex(_) => "create_index",
2193            Expression::DropIndex(_) => "drop_index",
2194            Expression::CreateView(_) => "create_view",
2195            Expression::DropView(_) => "drop_view",
2196            Expression::AlterView(_) => "alter_view",
2197            Expression::AlterIndex(_) => "alter_index",
2198            Expression::Truncate(_) => "truncate",
2199            Expression::Use(_) => "use",
2200            Expression::Cache(_) => "cache",
2201            Expression::Uncache(_) => "uncache",
2202            Expression::LoadData(_) => "load_data",
2203            Expression::Pragma(_) => "pragma",
2204            Expression::Grant(_) => "grant",
2205            Expression::Revoke(_) => "revoke",
2206            Expression::Comment(_) => "comment",
2207            Expression::SetStatement(_) => "set_statement",
2208            Expression::CreateSchema(_) => "create_schema",
2209            Expression::DropSchema(_) => "drop_schema",
2210            Expression::DropNamespace(_) => "drop_namespace",
2211            Expression::CreateDatabase(_) => "create_database",
2212            Expression::DropDatabase(_) => "drop_database",
2213            Expression::CreateFunction(_) => "create_function",
2214            Expression::DropFunction(_) => "drop_function",
2215            Expression::CreateProcedure(_) => "create_procedure",
2216            Expression::DropProcedure(_) => "drop_procedure",
2217            Expression::CreateSequence(_) => "create_sequence",
2218            Expression::CreateSynonym(_) => "create_synonym",
2219            Expression::DropSequence(_) => "drop_sequence",
2220            Expression::AlterSequence(_) => "alter_sequence",
2221            Expression::CreateTrigger(_) => "create_trigger",
2222            Expression::DropTrigger(_) => "drop_trigger",
2223            Expression::CreateType(_) => "create_type",
2224            Expression::DropType(_) => "drop_type",
2225            Expression::Describe(_) => "describe",
2226            Expression::Show(_) => "show",
2227            Expression::Command(_) => "command",
2228            Expression::Kill(_) => "kill",
2229            Expression::Execute(_) => "execute",
2230            Expression::Raw(_) => "raw",
2231            Expression::CreateTask(_) => "create_task",
2232            Expression::Paren(_) => "paren",
2233            Expression::Annotated(_) => "annotated",
2234            Expression::Refresh(_) => "refresh",
2235            Expression::LockingStatement(_) => "locking_statement",
2236            Expression::SequenceProperties(_) => "sequence_properties",
2237            Expression::TruncateTable(_) => "truncate_table",
2238            Expression::Clone(_) => "clone",
2239            Expression::Attach(_) => "attach",
2240            Expression::Detach(_) => "detach",
2241            Expression::Install(_) => "install",
2242            Expression::Summarize(_) => "summarize",
2243            Expression::Declare(_) => "declare",
2244            Expression::DeclareItem(_) => "declare_item",
2245            Expression::Set(_) => "set",
2246            Expression::Heredoc(_) => "heredoc",
2247            Expression::SetItem(_) => "set_item",
2248            Expression::QueryBand(_) => "query_band",
2249            Expression::UserDefinedFunction(_) => "user_defined_function",
2250            Expression::RecursiveWithSearch(_) => "recursive_with_search",
2251            Expression::ProjectionDef(_) => "projection_def",
2252            Expression::TableAlias(_) => "table_alias",
2253            Expression::ByteString(_) => "byte_string",
2254            Expression::HexStringExpr(_) => "hex_string_expr",
2255            Expression::UnicodeString(_) => "unicode_string",
2256            Expression::ColumnPosition(_) => "column_position",
2257            Expression::ColumnDef(_) => "column_def",
2258            Expression::AlterColumn(_) => "alter_column",
2259            Expression::AlterSortKey(_) => "alter_sort_key",
2260            Expression::AlterSet(_) => "alter_set",
2261            Expression::RenameColumn(_) => "rename_column",
2262            Expression::Comprehension(_) => "comprehension",
2263            Expression::MergeTreeTTLAction(_) => "merge_tree_t_t_l_action",
2264            Expression::MergeTreeTTL(_) => "merge_tree_t_t_l",
2265            Expression::IndexConstraintOption(_) => "index_constraint_option",
2266            Expression::ColumnConstraint(_) => "column_constraint",
2267            Expression::PeriodForSystemTimeConstraint(_) => "period_for_system_time_constraint",
2268            Expression::CaseSpecificColumnConstraint(_) => "case_specific_column_constraint",
2269            Expression::CharacterSetColumnConstraint(_) => "character_set_column_constraint",
2270            Expression::CheckColumnConstraint(_) => "check_column_constraint",
2271            Expression::AssumeColumnConstraint(_) => "assume_column_constraint",
2272            Expression::CompressColumnConstraint(_) => "compress_column_constraint",
2273            Expression::DateFormatColumnConstraint(_) => "date_format_column_constraint",
2274            Expression::EphemeralColumnConstraint(_) => "ephemeral_column_constraint",
2275            Expression::WithOperator(_) => "with_operator",
2276            Expression::GeneratedAsIdentityColumnConstraint(_) => {
2277                "generated_as_identity_column_constraint"
2278            }
2279            Expression::AutoIncrementColumnConstraint(_) => "auto_increment_column_constraint",
2280            Expression::CommentColumnConstraint(_) => "comment_column_constraint",
2281            Expression::GeneratedAsRowColumnConstraint(_) => "generated_as_row_column_constraint",
2282            Expression::IndexColumnConstraint(_) => "index_column_constraint",
2283            Expression::MaskingPolicyColumnConstraint(_) => "masking_policy_column_constraint",
2284            Expression::NotNullColumnConstraint(_) => "not_null_column_constraint",
2285            Expression::PrimaryKeyColumnConstraint(_) => "primary_key_column_constraint",
2286            Expression::UniqueColumnConstraint(_) => "unique_column_constraint",
2287            Expression::WatermarkColumnConstraint(_) => "watermark_column_constraint",
2288            Expression::ComputedColumnConstraint(_) => "computed_column_constraint",
2289            Expression::InOutColumnConstraint(_) => "in_out_column_constraint",
2290            Expression::DefaultColumnConstraint(_) => "default_column_constraint",
2291            Expression::PathColumnConstraint(_) => "path_column_constraint",
2292            Expression::Constraint(_) => "constraint",
2293            Expression::Export(_) => "export",
2294            Expression::Filter(_) => "filter",
2295            Expression::Changes(_) => "changes",
2296            Expression::CopyParameter(_) => "copy_parameter",
2297            Expression::Credentials(_) => "credentials",
2298            Expression::Directory(_) => "directory",
2299            Expression::ForeignKey(_) => "foreign_key",
2300            Expression::ColumnPrefix(_) => "column_prefix",
2301            Expression::PrimaryKey(_) => "primary_key",
2302            Expression::IntoClause(_) => "into_clause",
2303            Expression::JoinHint(_) => "join_hint",
2304            Expression::Opclass(_) => "opclass",
2305            Expression::Index(_) => "index",
2306            Expression::IndexParameters(_) => "index_parameters",
2307            Expression::ConditionalInsert(_) => "conditional_insert",
2308            Expression::MultitableInserts(_) => "multitable_inserts",
2309            Expression::OnConflict(_) => "on_conflict",
2310            Expression::OnCondition(_) => "on_condition",
2311            Expression::Returning(_) => "returning",
2312            Expression::Introducer(_) => "introducer",
2313            Expression::PartitionRange(_) => "partition_range",
2314            Expression::Fetch(_) => "fetch",
2315            Expression::Group(_) => "group",
2316            Expression::Cube(_) => "cube",
2317            Expression::Rollup(_) => "rollup",
2318            Expression::GroupingSets(_) => "grouping_sets",
2319            Expression::LimitOptions(_) => "limit_options",
2320            Expression::Lateral(_) => "lateral",
2321            Expression::TableFromRows(_) => "table_from_rows",
2322            Expression::RowsFrom(_) => "rows_from",
2323            Expression::MatchRecognizeMeasure(_) => "match_recognize_measure",
2324            Expression::WithFill(_) => "with_fill",
2325            Expression::Property(_) => "property",
2326            Expression::GrantPrivilege(_) => "grant_privilege",
2327            Expression::GrantPrincipal(_) => "grant_principal",
2328            Expression::AllowedValuesProperty(_) => "allowed_values_property",
2329            Expression::AlgorithmProperty(_) => "algorithm_property",
2330            Expression::AutoIncrementProperty(_) => "auto_increment_property",
2331            Expression::AutoRefreshProperty(_) => "auto_refresh_property",
2332            Expression::BackupProperty(_) => "backup_property",
2333            Expression::BuildProperty(_) => "build_property",
2334            Expression::BlockCompressionProperty(_) => "block_compression_property",
2335            Expression::CharacterSetProperty(_) => "character_set_property",
2336            Expression::ChecksumProperty(_) => "checksum_property",
2337            Expression::CollateProperty(_) => "collate_property",
2338            Expression::DataBlocksizeProperty(_) => "data_blocksize_property",
2339            Expression::DataDeletionProperty(_) => "data_deletion_property",
2340            Expression::DefinerProperty(_) => "definer_property",
2341            Expression::DistKeyProperty(_) => "dist_key_property",
2342            Expression::DistributedByProperty(_) => "distributed_by_property",
2343            Expression::DistStyleProperty(_) => "dist_style_property",
2344            Expression::DuplicateKeyProperty(_) => "duplicate_key_property",
2345            Expression::EngineProperty(_) => "engine_property",
2346            Expression::ToTableProperty(_) => "to_table_property",
2347            Expression::ExecuteAsProperty(_) => "execute_as_property",
2348            Expression::ExternalProperty(_) => "external_property",
2349            Expression::FallbackProperty(_) => "fallback_property",
2350            Expression::FileFormatProperty(_) => "file_format_property",
2351            Expression::CredentialsProperty(_) => "credentials_property",
2352            Expression::FreespaceProperty(_) => "freespace_property",
2353            Expression::InheritsProperty(_) => "inherits_property",
2354            Expression::InputModelProperty(_) => "input_model_property",
2355            Expression::OutputModelProperty(_) => "output_model_property",
2356            Expression::IsolatedLoadingProperty(_) => "isolated_loading_property",
2357            Expression::JournalProperty(_) => "journal_property",
2358            Expression::LanguageProperty(_) => "language_property",
2359            Expression::EnviromentProperty(_) => "enviroment_property",
2360            Expression::ClusteredByProperty(_) => "clustered_by_property",
2361            Expression::DictProperty(_) => "dict_property",
2362            Expression::DictRange(_) => "dict_range",
2363            Expression::OnCluster(_) => "on_cluster",
2364            Expression::LikeProperty(_) => "like_property",
2365            Expression::LocationProperty(_) => "location_property",
2366            Expression::LockProperty(_) => "lock_property",
2367            Expression::LockingProperty(_) => "locking_property",
2368            Expression::LogProperty(_) => "log_property",
2369            Expression::MaterializedProperty(_) => "materialized_property",
2370            Expression::MergeBlockRatioProperty(_) => "merge_block_ratio_property",
2371            Expression::OnProperty(_) => "on_property",
2372            Expression::OnCommitProperty(_) => "on_commit_property",
2373            Expression::PartitionedByProperty(_) => "partitioned_by_property",
2374            Expression::PartitionByProperty(_) => "partition_by_property",
2375            Expression::PartitionedByBucket(_) => "partitioned_by_bucket",
2376            Expression::ClusterByColumnsProperty(_) => "cluster_by_columns_property",
2377            Expression::PartitionByTruncate(_) => "partition_by_truncate",
2378            Expression::PartitionByRangeProperty(_) => "partition_by_range_property",
2379            Expression::PartitionByRangePropertyDynamic(_) => "partition_by_range_property_dynamic",
2380            Expression::PartitionByListProperty(_) => "partition_by_list_property",
2381            Expression::PartitionList(_) => "partition_list",
2382            Expression::Partition(_) => "partition",
2383            Expression::RefreshTriggerProperty(_) => "refresh_trigger_property",
2384            Expression::UniqueKeyProperty(_) => "unique_key_property",
2385            Expression::RollupProperty(_) => "rollup_property",
2386            Expression::PartitionBoundSpec(_) => "partition_bound_spec",
2387            Expression::PartitionedOfProperty(_) => "partitioned_of_property",
2388            Expression::RemoteWithConnectionModelProperty(_) => {
2389                "remote_with_connection_model_property"
2390            }
2391            Expression::ReturnsProperty(_) => "returns_property",
2392            Expression::RowFormatProperty(_) => "row_format_property",
2393            Expression::RowFormatDelimitedProperty(_) => "row_format_delimited_property",
2394            Expression::RowFormatSerdeProperty(_) => "row_format_serde_property",
2395            Expression::QueryTransform(_) => "query_transform",
2396            Expression::SampleProperty(_) => "sample_property",
2397            Expression::SecurityProperty(_) => "security_property",
2398            Expression::SchemaCommentProperty(_) => "schema_comment_property",
2399            Expression::SemanticView(_) => "semantic_view",
2400            Expression::SerdeProperties(_) => "serde_properties",
2401            Expression::SetProperty(_) => "set_property",
2402            Expression::SharingProperty(_) => "sharing_property",
2403            Expression::SetConfigProperty(_) => "set_config_property",
2404            Expression::SettingsProperty(_) => "settings_property",
2405            Expression::SortKeyProperty(_) => "sort_key_property",
2406            Expression::SqlReadWriteProperty(_) => "sql_read_write_property",
2407            Expression::SqlSecurityProperty(_) => "sql_security_property",
2408            Expression::StabilityProperty(_) => "stability_property",
2409            Expression::StorageHandlerProperty(_) => "storage_handler_property",
2410            Expression::TemporaryProperty(_) => "temporary_property",
2411            Expression::Tags(_) => "tags",
2412            Expression::TransformModelProperty(_) => "transform_model_property",
2413            Expression::TransientProperty(_) => "transient_property",
2414            Expression::UsingTemplateProperty(_) => "using_template_property",
2415            Expression::ViewAttributeProperty(_) => "view_attribute_property",
2416            Expression::VolatileProperty(_) => "volatile_property",
2417            Expression::WithDataProperty(_) => "with_data_property",
2418            Expression::WithJournalTableProperty(_) => "with_journal_table_property",
2419            Expression::WithSchemaBindingProperty(_) => "with_schema_binding_property",
2420            Expression::WithSystemVersioningProperty(_) => "with_system_versioning_property",
2421            Expression::WithProcedureOptions(_) => "with_procedure_options",
2422            Expression::EncodeProperty(_) => "encode_property",
2423            Expression::IncludeProperty(_) => "include_property",
2424            Expression::Properties(_) => "properties",
2425            Expression::OptionsProperty(_) => "options_property",
2426            Expression::InputOutputFormat(_) => "input_output_format",
2427            Expression::Reference(_) => "reference",
2428            Expression::QueryOption(_) => "query_option",
2429            Expression::WithTableHint(_) => "with_table_hint",
2430            Expression::IndexTableHint(_) => "index_table_hint",
2431            Expression::HistoricalData(_) => "historical_data",
2432            Expression::Get(_) => "get",
2433            Expression::SetOperation(_) => "set_operation",
2434            Expression::Var(_) => "var",
2435            Expression::Variadic(_) => "variadic",
2436            Expression::Version(_) => "version",
2437            Expression::Schema(_) => "schema",
2438            Expression::Lock(_) => "lock",
2439            Expression::TableSample(_) => "table_sample",
2440            Expression::Tag(_) => "tag",
2441            Expression::UnpivotColumns(_) => "unpivot_columns",
2442            Expression::WindowSpec(_) => "window_spec",
2443            Expression::SessionParameter(_) => "session_parameter",
2444            Expression::PseudoType(_) => "pseudo_type",
2445            Expression::ObjectIdentifier(_) => "object_identifier",
2446            Expression::Transaction(_) => "transaction",
2447            Expression::Commit(_) => "commit",
2448            Expression::Rollback(_) => "rollback",
2449            Expression::AlterSession(_) => "alter_session",
2450            Expression::Analyze(_) => "analyze",
2451            Expression::AnalyzeStatistics(_) => "analyze_statistics",
2452            Expression::AnalyzeHistogram(_) => "analyze_histogram",
2453            Expression::AnalyzeSample(_) => "analyze_sample",
2454            Expression::AnalyzeListChainedRows(_) => "analyze_list_chained_rows",
2455            Expression::AnalyzeDelete(_) => "analyze_delete",
2456            Expression::AnalyzeWith(_) => "analyze_with",
2457            Expression::AnalyzeValidate(_) => "analyze_validate",
2458            Expression::AddPartition(_) => "add_partition",
2459            Expression::AttachOption(_) => "attach_option",
2460            Expression::DropPartition(_) => "drop_partition",
2461            Expression::ReplacePartition(_) => "replace_partition",
2462            Expression::DPipe(_) => "d_pipe",
2463            Expression::Operator(_) => "operator",
2464            Expression::PivotAny(_) => "pivot_any",
2465            Expression::Aliases(_) => "aliases",
2466            Expression::AtIndex(_) => "at_index",
2467            Expression::FromTimeZone(_) => "from_time_zone",
2468            Expression::FormatPhrase(_) => "format_phrase",
2469            Expression::ForIn(_) => "for_in",
2470            Expression::TimeUnit(_) => "time_unit",
2471            Expression::IntervalOp(_) => "interval_op",
2472            Expression::IntervalSpan(_) => "interval_span",
2473            Expression::HavingMax(_) => "having_max",
2474            Expression::CosineDistance(_) => "cosine_distance",
2475            Expression::DotProduct(_) => "dot_product",
2476            Expression::EuclideanDistance(_) => "euclidean_distance",
2477            Expression::ManhattanDistance(_) => "manhattan_distance",
2478            Expression::JarowinklerSimilarity(_) => "jarowinkler_similarity",
2479            Expression::Booland(_) => "booland",
2480            Expression::Boolor(_) => "boolor",
2481            Expression::ParameterizedAgg(_) => "parameterized_agg",
2482            Expression::ArgMax(_) => "arg_max",
2483            Expression::ArgMin(_) => "arg_min",
2484            Expression::ApproxTopK(_) => "approx_top_k",
2485            Expression::ApproxTopKAccumulate(_) => "approx_top_k_accumulate",
2486            Expression::ApproxTopKCombine(_) => "approx_top_k_combine",
2487            Expression::ApproxTopKEstimate(_) => "approx_top_k_estimate",
2488            Expression::ApproxTopSum(_) => "approx_top_sum",
2489            Expression::ApproxQuantiles(_) => "approx_quantiles",
2490            Expression::Minhash(_) => "minhash",
2491            Expression::FarmFingerprint(_) => "farm_fingerprint",
2492            Expression::Float64(_) => "float64",
2493            Expression::Transform(_) => "transform",
2494            Expression::Translate(_) => "translate",
2495            Expression::Grouping(_) => "grouping",
2496            Expression::GroupingId(_) => "grouping_id",
2497            Expression::Anonymous(_) => "anonymous",
2498            Expression::AnonymousAggFunc(_) => "anonymous_agg_func",
2499            Expression::CombinedAggFunc(_) => "combined_agg_func",
2500            Expression::CombinedParameterizedAgg(_) => "combined_parameterized_agg",
2501            Expression::HashAgg(_) => "hash_agg",
2502            Expression::Hll(_) => "hll",
2503            Expression::Apply(_) => "apply",
2504            Expression::ToBoolean(_) => "to_boolean",
2505            Expression::List(_) => "list",
2506            Expression::ToMap(_) => "to_map",
2507            Expression::Pad(_) => "pad",
2508            Expression::ToChar(_) => "to_char",
2509            Expression::ToNumber(_) => "to_number",
2510            Expression::ToDouble(_) => "to_double",
2511            Expression::Int64(_) => "int64",
2512            Expression::StringFunc(_) => "string_func",
2513            Expression::ToDecfloat(_) => "to_decfloat",
2514            Expression::TryToDecfloat(_) => "try_to_decfloat",
2515            Expression::ToFile(_) => "to_file",
2516            Expression::Columns(_) => "columns",
2517            Expression::ConvertToCharset(_) => "convert_to_charset",
2518            Expression::ConvertTimezone(_) => "convert_timezone",
2519            Expression::GenerateSeries(_) => "generate_series",
2520            Expression::AIAgg(_) => "a_i_agg",
2521            Expression::AIClassify(_) => "a_i_classify",
2522            Expression::ArrayAll(_) => "array_all",
2523            Expression::ArrayAny(_) => "array_any",
2524            Expression::ArrayConstructCompact(_) => "array_construct_compact",
2525            Expression::StPoint(_) => "st_point",
2526            Expression::StDistance(_) => "st_distance",
2527            Expression::StringToArray(_) => "string_to_array",
2528            Expression::ArraySum(_) => "array_sum",
2529            Expression::ObjectAgg(_) => "object_agg",
2530            Expression::CastToStrType(_) => "cast_to_str_type",
2531            Expression::CheckJson(_) => "check_json",
2532            Expression::CheckXml(_) => "check_xml",
2533            Expression::TranslateCharacters(_) => "translate_characters",
2534            Expression::CurrentSchemas(_) => "current_schemas",
2535            Expression::CurrentDatetime(_) => "current_datetime",
2536            Expression::Localtime(_) => "localtime",
2537            Expression::Localtimestamp(_) => "localtimestamp",
2538            Expression::Systimestamp(_) => "systimestamp",
2539            Expression::CurrentSchema(_) => "current_schema",
2540            Expression::CurrentUser(_) => "current_user",
2541            Expression::UtcTime(_) => "utc_time",
2542            Expression::UtcTimestamp(_) => "utc_timestamp",
2543            Expression::Timestamp(_) => "timestamp",
2544            Expression::DateBin(_) => "date_bin",
2545            Expression::Datetime(_) => "datetime",
2546            Expression::DatetimeAdd(_) => "datetime_add",
2547            Expression::DatetimeSub(_) => "datetime_sub",
2548            Expression::DatetimeDiff(_) => "datetime_diff",
2549            Expression::DatetimeTrunc(_) => "datetime_trunc",
2550            Expression::Dayname(_) => "dayname",
2551            Expression::MakeInterval(_) => "make_interval",
2552            Expression::PreviousDay(_) => "previous_day",
2553            Expression::Elt(_) => "elt",
2554            Expression::TimestampAdd(_) => "timestamp_add",
2555            Expression::TimestampSub(_) => "timestamp_sub",
2556            Expression::TimestampDiff(_) => "timestamp_diff",
2557            Expression::TimeSlice(_) => "time_slice",
2558            Expression::TimeAdd(_) => "time_add",
2559            Expression::TimeSub(_) => "time_sub",
2560            Expression::TimeDiff(_) => "time_diff",
2561            Expression::TimeTrunc(_) => "time_trunc",
2562            Expression::DateFromParts(_) => "date_from_parts",
2563            Expression::TimeFromParts(_) => "time_from_parts",
2564            Expression::DecodeCase(_) => "decode_case",
2565            Expression::Decrypt(_) => "decrypt",
2566            Expression::DecryptRaw(_) => "decrypt_raw",
2567            Expression::Encode(_) => "encode",
2568            Expression::Encrypt(_) => "encrypt",
2569            Expression::EncryptRaw(_) => "encrypt_raw",
2570            Expression::EqualNull(_) => "equal_null",
2571            Expression::ToBinary(_) => "to_binary",
2572            Expression::Base64DecodeBinary(_) => "base64_decode_binary",
2573            Expression::Base64DecodeString(_) => "base64_decode_string",
2574            Expression::Base64Encode(_) => "base64_encode",
2575            Expression::TryBase64DecodeBinary(_) => "try_base64_decode_binary",
2576            Expression::TryBase64DecodeString(_) => "try_base64_decode_string",
2577            Expression::GapFill(_) => "gap_fill",
2578            Expression::GenerateDateArray(_) => "generate_date_array",
2579            Expression::GenerateTimestampArray(_) => "generate_timestamp_array",
2580            Expression::GetExtract(_) => "get_extract",
2581            Expression::Getbit(_) => "getbit",
2582            Expression::OverflowTruncateBehavior(_) => "overflow_truncate_behavior",
2583            Expression::HexEncode(_) => "hex_encode",
2584            Expression::Compress(_) => "compress",
2585            Expression::DecompressBinary(_) => "decompress_binary",
2586            Expression::DecompressString(_) => "decompress_string",
2587            Expression::Xor(_) => "xor",
2588            Expression::Nullif(_) => "nullif",
2589            Expression::JSON(_) => "j_s_o_n",
2590            Expression::JSONPath(_) => "j_s_o_n_path",
2591            Expression::JSONPathFilter(_) => "j_s_o_n_path_filter",
2592            Expression::JSONPathKey(_) => "j_s_o_n_path_key",
2593            Expression::JSONPathRecursive(_) => "j_s_o_n_path_recursive",
2594            Expression::JSONPathScript(_) => "j_s_o_n_path_script",
2595            Expression::JSONPathSlice(_) => "j_s_o_n_path_slice",
2596            Expression::JSONPathSelector(_) => "j_s_o_n_path_selector",
2597            Expression::JSONPathSubscript(_) => "j_s_o_n_path_subscript",
2598            Expression::JSONPathUnion(_) => "j_s_o_n_path_union",
2599            Expression::Format(_) => "format",
2600            Expression::JSONKeys(_) => "j_s_o_n_keys",
2601            Expression::JSONKeyValue(_) => "j_s_o_n_key_value",
2602            Expression::JSONKeysAtDepth(_) => "j_s_o_n_keys_at_depth",
2603            Expression::JSONObject(_) => "j_s_o_n_object",
2604            Expression::JSONObjectAgg(_) => "j_s_o_n_object_agg",
2605            Expression::JSONBObjectAgg(_) => "j_s_o_n_b_object_agg",
2606            Expression::JSONArray(_) => "j_s_o_n_array",
2607            Expression::JSONArrayAgg(_) => "j_s_o_n_array_agg",
2608            Expression::JSONExists(_) => "j_s_o_n_exists",
2609            Expression::JSONColumnDef(_) => "j_s_o_n_column_def",
2610            Expression::JSONSchema(_) => "j_s_o_n_schema",
2611            Expression::JSONSet(_) => "j_s_o_n_set",
2612            Expression::JSONStripNulls(_) => "j_s_o_n_strip_nulls",
2613            Expression::JSONValue(_) => "j_s_o_n_value",
2614            Expression::JSONValueArray(_) => "j_s_o_n_value_array",
2615            Expression::JSONRemove(_) => "j_s_o_n_remove",
2616            Expression::JSONTable(_) => "j_s_o_n_table",
2617            Expression::JSONType(_) => "j_s_o_n_type",
2618            Expression::ObjectInsert(_) => "object_insert",
2619            Expression::OpenJSONColumnDef(_) => "open_j_s_o_n_column_def",
2620            Expression::OpenJSON(_) => "open_j_s_o_n",
2621            Expression::JSONBExists(_) => "j_s_o_n_b_exists",
2622            Expression::JSONBContains(_) => "j_s_o_n_b_contains",
2623            Expression::JSONBExtract(_) => "j_s_o_n_b_extract",
2624            Expression::JSONCast(_) => "j_s_o_n_cast",
2625            Expression::JSONExtract(_) => "j_s_o_n_extract",
2626            Expression::JSONExtractQuote(_) => "j_s_o_n_extract_quote",
2627            Expression::JSONExtractArray(_) => "j_s_o_n_extract_array",
2628            Expression::JSONExtractScalar(_) => "j_s_o_n_extract_scalar",
2629            Expression::JSONBExtractScalar(_) => "j_s_o_n_b_extract_scalar",
2630            Expression::JSONFormat(_) => "j_s_o_n_format",
2631            Expression::JSONBool(_) => "j_s_o_n_bool",
2632            Expression::JSONPathRoot(_) => "j_s_o_n_path_root",
2633            Expression::JSONArrayAppend(_) => "j_s_o_n_array_append",
2634            Expression::JSONArrayContains(_) => "j_s_o_n_array_contains",
2635            Expression::JSONArrayInsert(_) => "j_s_o_n_array_insert",
2636            Expression::ParseJSON(_) => "parse_j_s_o_n",
2637            Expression::ParseUrl(_) => "parse_url",
2638            Expression::ParseIp(_) => "parse_ip",
2639            Expression::ParseTime(_) => "parse_time",
2640            Expression::ParseDatetime(_) => "parse_datetime",
2641            Expression::Map(_) => "map",
2642            Expression::MapCat(_) => "map_cat",
2643            Expression::MapDelete(_) => "map_delete",
2644            Expression::MapInsert(_) => "map_insert",
2645            Expression::MapPick(_) => "map_pick",
2646            Expression::ScopeResolution(_) => "scope_resolution",
2647            Expression::Slice(_) => "slice",
2648            Expression::VarMap(_) => "var_map",
2649            Expression::MatchAgainst(_) => "match_against",
2650            Expression::MD5Digest(_) => "m_d5_digest",
2651            Expression::MD5NumberLower64(_) => "m_d5_number_lower64",
2652            Expression::MD5NumberUpper64(_) => "m_d5_number_upper64",
2653            Expression::Monthname(_) => "monthname",
2654            Expression::Ntile(_) => "ntile",
2655            Expression::Normalize(_) => "normalize",
2656            Expression::Normal(_) => "normal",
2657            Expression::Predict(_) => "predict",
2658            Expression::MLTranslate(_) => "m_l_translate",
2659            Expression::FeaturesAtTime(_) => "features_at_time",
2660            Expression::GenerateEmbedding(_) => "generate_embedding",
2661            Expression::MLForecast(_) => "m_l_forecast",
2662            Expression::ModelAttribute(_) => "model_attribute",
2663            Expression::VectorSearch(_) => "vector_search",
2664            Expression::Quantile(_) => "quantile",
2665            Expression::ApproxQuantile(_) => "approx_quantile",
2666            Expression::ApproxPercentileEstimate(_) => "approx_percentile_estimate",
2667            Expression::Randn(_) => "randn",
2668            Expression::Randstr(_) => "randstr",
2669            Expression::RangeN(_) => "range_n",
2670            Expression::RangeBucket(_) => "range_bucket",
2671            Expression::ReadCSV(_) => "read_c_s_v",
2672            Expression::ReadParquet(_) => "read_parquet",
2673            Expression::Reduce(_) => "reduce",
2674            Expression::RegexpExtractAll(_) => "regexp_extract_all",
2675            Expression::RegexpILike(_) => "regexp_i_like",
2676            Expression::RegexpFullMatch(_) => "regexp_full_match",
2677            Expression::RegexpInstr(_) => "regexp_instr",
2678            Expression::RegexpSplit(_) => "regexp_split",
2679            Expression::RegexpCount(_) => "regexp_count",
2680            Expression::RegrValx(_) => "regr_valx",
2681            Expression::RegrValy(_) => "regr_valy",
2682            Expression::RegrAvgy(_) => "regr_avgy",
2683            Expression::RegrAvgx(_) => "regr_avgx",
2684            Expression::RegrCount(_) => "regr_count",
2685            Expression::RegrIntercept(_) => "regr_intercept",
2686            Expression::RegrR2(_) => "regr_r2",
2687            Expression::RegrSxx(_) => "regr_sxx",
2688            Expression::RegrSxy(_) => "regr_sxy",
2689            Expression::RegrSyy(_) => "regr_syy",
2690            Expression::RegrSlope(_) => "regr_slope",
2691            Expression::SafeAdd(_) => "safe_add",
2692            Expression::SafeDivide(_) => "safe_divide",
2693            Expression::SafeMultiply(_) => "safe_multiply",
2694            Expression::SafeSubtract(_) => "safe_subtract",
2695            Expression::SHA2(_) => "s_h_a2",
2696            Expression::SHA2Digest(_) => "s_h_a2_digest",
2697            Expression::SortArray(_) => "sort_array",
2698            Expression::SplitPart(_) => "split_part",
2699            Expression::SubstringIndex(_) => "substring_index",
2700            Expression::StandardHash(_) => "standard_hash",
2701            Expression::StrPosition(_) => "str_position",
2702            Expression::Search(_) => "search",
2703            Expression::SearchIp(_) => "search_ip",
2704            Expression::StrToDate(_) => "str_to_date",
2705            Expression::DateStrToDate(_) => "date_str_to_date",
2706            Expression::DateToDateStr(_) => "date_to_date_str",
2707            Expression::StrToTime(_) => "str_to_time",
2708            Expression::StrToUnix(_) => "str_to_unix",
2709            Expression::StrToMap(_) => "str_to_map",
2710            Expression::NumberToStr(_) => "number_to_str",
2711            Expression::FromBase(_) => "from_base",
2712            Expression::Stuff(_) => "stuff",
2713            Expression::TimeToStr(_) => "time_to_str",
2714            Expression::TimeStrToTime(_) => "time_str_to_time",
2715            Expression::TsOrDsAdd(_) => "ts_or_ds_add",
2716            Expression::TsOrDsDiff(_) => "ts_or_ds_diff",
2717            Expression::TsOrDsToDate(_) => "ts_or_ds_to_date",
2718            Expression::TsOrDsToTime(_) => "ts_or_ds_to_time",
2719            Expression::Unhex(_) => "unhex",
2720            Expression::Uniform(_) => "uniform",
2721            Expression::UnixToStr(_) => "unix_to_str",
2722            Expression::UnixToTime(_) => "unix_to_time",
2723            Expression::Uuid(_) => "uuid",
2724            Expression::TimestampFromParts(_) => "timestamp_from_parts",
2725            Expression::TimestampTzFromParts(_) => "timestamp_tz_from_parts",
2726            Expression::Corr(_) => "corr",
2727            Expression::WidthBucket(_) => "width_bucket",
2728            Expression::CovarSamp(_) => "covar_samp",
2729            Expression::CovarPop(_) => "covar_pop",
2730            Expression::Week(_) => "week",
2731            Expression::XMLElement(_) => "x_m_l_element",
2732            Expression::XMLGet(_) => "x_m_l_get",
2733            Expression::XMLTable(_) => "x_m_l_table",
2734            Expression::XMLKeyValueOption(_) => "x_m_l_key_value_option",
2735            Expression::Zipf(_) => "zipf",
2736            Expression::Merge(_) => "merge",
2737            Expression::When(_) => "when",
2738            Expression::Whens(_) => "whens",
2739            Expression::NextValueFor(_) => "next_value_for",
2740            Expression::ReturnStmt(_) => "return_stmt",
2741        }
2742    }
2743
2744    /// Returns the primary child expression (".this" in sqlglot).
2745    pub fn get_this(&self) -> Option<&Expression> {
2746        match self {
2747            // Unary ops
2748            Expression::Not(u) | Expression::Neg(u) | Expression::BitwiseNot(u) => Some(&u.this),
2749            // UnaryFunc variants
2750            Expression::Upper(f)
2751            | Expression::Lower(f)
2752            | Expression::Length(f)
2753            | Expression::LTrim(f)
2754            | Expression::RTrim(f)
2755            | Expression::Reverse(f)
2756            | Expression::Abs(f)
2757            | Expression::Sqrt(f)
2758            | Expression::Cbrt(f)
2759            | Expression::Ln(f)
2760            | Expression::Exp(f)
2761            | Expression::Sign(f)
2762            | Expression::Date(f)
2763            | Expression::Time(f)
2764            | Expression::Initcap(f)
2765            | Expression::Ascii(f)
2766            | Expression::Chr(f)
2767            | Expression::Soundex(f)
2768            | Expression::ByteLength(f)
2769            | Expression::Hex(f)
2770            | Expression::LowerHex(f)
2771            | Expression::Unicode(f)
2772            | Expression::Typeof(f)
2773            | Expression::Explode(f)
2774            | Expression::ExplodeOuter(f)
2775            | Expression::MapFromEntries(f)
2776            | Expression::MapKeys(f)
2777            | Expression::MapValues(f)
2778            | Expression::ArrayLength(f)
2779            | Expression::ArraySize(f)
2780            | Expression::Cardinality(f)
2781            | Expression::ArrayReverse(f)
2782            | Expression::ArrayDistinct(f)
2783            | Expression::ArrayFlatten(f)
2784            | Expression::ArrayCompact(f)
2785            | Expression::ToArray(f)
2786            | Expression::JsonArrayLength(f)
2787            | Expression::JsonKeys(f)
2788            | Expression::JsonType(f)
2789            | Expression::ParseJson(f)
2790            | Expression::ToJson(f)
2791            | Expression::Radians(f)
2792            | Expression::Degrees(f)
2793            | Expression::Sin(f)
2794            | Expression::Cos(f)
2795            | Expression::Tan(f)
2796            | Expression::Asin(f)
2797            | Expression::Acos(f)
2798            | Expression::Atan(f)
2799            | Expression::IsNan(f)
2800            | Expression::IsInf(f)
2801            | Expression::Year(f)
2802            | Expression::Month(f)
2803            | Expression::Day(f)
2804            | Expression::Hour(f)
2805            | Expression::Minute(f)
2806            | Expression::Second(f)
2807            | Expression::DayOfWeek(f)
2808            | Expression::DayOfWeekIso(f)
2809            | Expression::DayOfMonth(f)
2810            | Expression::DayOfYear(f)
2811            | Expression::WeekOfYear(f)
2812            | Expression::Quarter(f)
2813            | Expression::Epoch(f)
2814            | Expression::EpochMs(f)
2815            | Expression::BitwiseCount(f)
2816            | Expression::DateFromUnixDate(f)
2817            | Expression::UnixDate(f)
2818            | Expression::UnixSeconds(f)
2819            | Expression::UnixMillis(f)
2820            | Expression::UnixMicros(f)
2821            | Expression::TimeStrToDate(f)
2822            | Expression::DateToDi(f)
2823            | Expression::DiToDate(f)
2824            | Expression::TsOrDiToDi(f)
2825            | Expression::TsOrDsToDatetime(f)
2826            | Expression::TsOrDsToTimestamp(f)
2827            | Expression::YearOfWeek(f)
2828            | Expression::YearOfWeekIso(f)
2829            | Expression::SHA(f)
2830            | Expression::SHA1Digest(f)
2831            | Expression::TimeToUnix(f)
2832            | Expression::TimeStrToUnix(f)
2833            | Expression::Int64(f)
2834            | Expression::JSONBool(f)
2835            | Expression::MD5NumberLower64(f)
2836            | Expression::MD5NumberUpper64(f)
2837            | Expression::DateStrToDate(f)
2838            | Expression::DateToDateStr(f) => Some(&f.this),
2839            // BinaryFunc - this is the primary child
2840            Expression::Power(f)
2841            | Expression::NullIf(f)
2842            | Expression::IfNull(f)
2843            | Expression::Nvl(f)
2844            | Expression::Contains(f)
2845            | Expression::StartsWith(f)
2846            | Expression::EndsWith(f)
2847            | Expression::Levenshtein(f)
2848            | Expression::ModFunc(f)
2849            | Expression::IntDiv(f)
2850            | Expression::Atan2(f)
2851            | Expression::AddMonths(f)
2852            | Expression::MonthsBetween(f)
2853            | Expression::NextDay(f)
2854            | Expression::UnixToTimeStr(f)
2855            | Expression::ArrayContains(f)
2856            | Expression::ArrayPosition(f)
2857            | Expression::ArrayAppend(f)
2858            | Expression::ArrayPrepend(f)
2859            | Expression::ArrayUnion(f)
2860            | Expression::ArrayExcept(f)
2861            | Expression::ArrayRemove(f)
2862            | Expression::StarMap(f)
2863            | Expression::MapFromArrays(f)
2864            | Expression::MapContainsKey(f)
2865            | Expression::ElementAt(f)
2866            | Expression::JsonMergePatch(f)
2867            | Expression::JSONBContains(f)
2868            | Expression::JSONBExtract(f) => Some(&f.this),
2869            // AggFunc - this is the primary child
2870            Expression::Sum(af)
2871            | Expression::Avg(af)
2872            | Expression::Min(af)
2873            | Expression::Max(af)
2874            | Expression::ArrayAgg(af)
2875            | Expression::CountIf(af)
2876            | Expression::Stddev(af)
2877            | Expression::StddevPop(af)
2878            | Expression::StddevSamp(af)
2879            | Expression::Variance(af)
2880            | Expression::VarPop(af)
2881            | Expression::VarSamp(af)
2882            | Expression::Median(af)
2883            | Expression::Mode(af)
2884            | Expression::First(af)
2885            | Expression::Last(af)
2886            | Expression::AnyValue(af)
2887            | Expression::ApproxDistinct(af)
2888            | Expression::ApproxCountDistinct(af)
2889            | Expression::LogicalAnd(af)
2890            | Expression::LogicalOr(af)
2891            | Expression::Skewness(af)
2892            | Expression::ArrayConcatAgg(af)
2893            | Expression::ArrayUniqueAgg(af)
2894            | Expression::BoolXorAgg(af)
2895            | Expression::BitwiseAndAgg(af)
2896            | Expression::BitwiseOrAgg(af)
2897            | Expression::BitwiseXorAgg(af) => Some(&af.this),
2898            // Binary operations - left is "this" in sqlglot
2899            Expression::And(op)
2900            | Expression::Or(op)
2901            | Expression::Add(op)
2902            | Expression::Sub(op)
2903            | Expression::Mul(op)
2904            | Expression::Div(op)
2905            | Expression::Mod(op)
2906            | Expression::Eq(op)
2907            | Expression::Neq(op)
2908            | Expression::Lt(op)
2909            | Expression::Lte(op)
2910            | Expression::Gt(op)
2911            | Expression::Gte(op)
2912            | Expression::BitwiseAnd(op)
2913            | Expression::BitwiseOr(op)
2914            | Expression::BitwiseXor(op)
2915            | Expression::Concat(op)
2916            | Expression::Adjacent(op)
2917            | Expression::TsMatch(op)
2918            | Expression::PropertyEQ(op)
2919            | Expression::ArrayContainsAll(op)
2920            | Expression::ArrayContainedBy(op)
2921            | Expression::ArrayOverlaps(op)
2922            | Expression::JSONBContainsAllTopKeys(op)
2923            | Expression::JSONBContainsAnyTopKeys(op)
2924            | Expression::JSONBDeleteAtPath(op)
2925            | Expression::ExtendsLeft(op)
2926            | Expression::ExtendsRight(op)
2927            | Expression::Is(op)
2928            | Expression::MemberOf(op)
2929            | Expression::Match(op)
2930            | Expression::NullSafeEq(op)
2931            | Expression::NullSafeNeq(op)
2932            | Expression::Glob(op)
2933            | Expression::BitwiseLeftShift(op)
2934            | Expression::BitwiseRightShift(op) => Some(&op.left),
2935            // Like operations - left is "this"
2936            Expression::Like(op) | Expression::ILike(op) => Some(&op.left),
2937            // Structural types with .this
2938            Expression::Alias(a) => Some(&a.this),
2939            Expression::Cast(c) | Expression::TryCast(c) | Expression::SafeCast(c) => Some(&c.this),
2940            Expression::Paren(p) => Some(&p.this),
2941            Expression::Annotated(a) => Some(&a.this),
2942            Expression::Subquery(s) => Some(&s.this),
2943            Expression::Where(w) => Some(&w.this),
2944            Expression::Having(h) => Some(&h.this),
2945            Expression::Qualify(q) => Some(&q.this),
2946            Expression::IsNull(i) => Some(&i.this),
2947            Expression::Exists(e) => Some(&e.this),
2948            Expression::Ordered(o) => Some(&o.this),
2949            Expression::WindowFunction(wf) => Some(&wf.this),
2950            Expression::Cte(cte) => Some(&cte.this),
2951            Expression::Between(b) => Some(&b.this),
2952            Expression::In(i) => Some(&i.this),
2953            Expression::ReturnStmt(e) => Some(e),
2954            _ => None,
2955        }
2956    }
2957
2958    /// Returns the secondary child expression (".expression" in sqlglot).
2959    pub fn get_expression(&self) -> Option<&Expression> {
2960        match self {
2961            // Binary operations - right is "expression"
2962            Expression::And(op)
2963            | Expression::Or(op)
2964            | Expression::Add(op)
2965            | Expression::Sub(op)
2966            | Expression::Mul(op)
2967            | Expression::Div(op)
2968            | Expression::Mod(op)
2969            | Expression::Eq(op)
2970            | Expression::Neq(op)
2971            | Expression::Lt(op)
2972            | Expression::Lte(op)
2973            | Expression::Gt(op)
2974            | Expression::Gte(op)
2975            | Expression::BitwiseAnd(op)
2976            | Expression::BitwiseOr(op)
2977            | Expression::BitwiseXor(op)
2978            | Expression::Concat(op)
2979            | Expression::Adjacent(op)
2980            | Expression::TsMatch(op)
2981            | Expression::PropertyEQ(op)
2982            | Expression::ArrayContainsAll(op)
2983            | Expression::ArrayContainedBy(op)
2984            | Expression::ArrayOverlaps(op)
2985            | Expression::JSONBContainsAllTopKeys(op)
2986            | Expression::JSONBContainsAnyTopKeys(op)
2987            | Expression::JSONBDeleteAtPath(op)
2988            | Expression::ExtendsLeft(op)
2989            | Expression::ExtendsRight(op)
2990            | Expression::Is(op)
2991            | Expression::MemberOf(op)
2992            | Expression::Match(op)
2993            | Expression::NullSafeEq(op)
2994            | Expression::NullSafeNeq(op)
2995            | Expression::Glob(op)
2996            | Expression::BitwiseLeftShift(op)
2997            | Expression::BitwiseRightShift(op) => Some(&op.right),
2998            // Like operations - right is "expression"
2999            Expression::Like(op) | Expression::ILike(op) => Some(&op.right),
3000            // BinaryFunc - expression is the secondary
3001            Expression::Power(f)
3002            | Expression::NullIf(f)
3003            | Expression::IfNull(f)
3004            | Expression::Nvl(f)
3005            | Expression::Contains(f)
3006            | Expression::StartsWith(f)
3007            | Expression::EndsWith(f)
3008            | Expression::Levenshtein(f)
3009            | Expression::ModFunc(f)
3010            | Expression::IntDiv(f)
3011            | Expression::Atan2(f)
3012            | Expression::AddMonths(f)
3013            | Expression::MonthsBetween(f)
3014            | Expression::NextDay(f)
3015            | Expression::UnixToTimeStr(f)
3016            | Expression::ArrayContains(f)
3017            | Expression::ArrayPosition(f)
3018            | Expression::ArrayAppend(f)
3019            | Expression::ArrayPrepend(f)
3020            | Expression::ArrayUnion(f)
3021            | Expression::ArrayExcept(f)
3022            | Expression::ArrayRemove(f)
3023            | Expression::StarMap(f)
3024            | Expression::MapFromArrays(f)
3025            | Expression::MapContainsKey(f)
3026            | Expression::ElementAt(f)
3027            | Expression::JsonMergePatch(f)
3028            | Expression::JSONBContains(f)
3029            | Expression::JSONBExtract(f) => Some(&f.expression),
3030            _ => None,
3031        }
3032    }
3033
3034    /// Returns the list of child expressions (".expressions" in sqlglot).
3035    pub fn get_expressions(&self) -> &[Expression] {
3036        match self {
3037            Expression::Select(s) => &s.expressions,
3038            Expression::Function(f) => &f.args,
3039            Expression::AggregateFunction(f) => &f.args,
3040            Expression::From(f) => &f.expressions,
3041            Expression::GroupBy(g) => &g.expressions,
3042            Expression::In(i) => &i.expressions,
3043            Expression::Array(a) => &a.expressions,
3044            Expression::Tuple(t) => &t.expressions,
3045            Expression::Coalesce(f)
3046            | Expression::Greatest(f)
3047            | Expression::Least(f)
3048            | Expression::ArrayConcat(f)
3049            | Expression::ArrayIntersect(f)
3050            | Expression::ArrayZip(f)
3051            | Expression::MapConcat(f)
3052            | Expression::JsonArray(f) => &f.expressions,
3053            _ => &[],
3054        }
3055    }
3056
3057    /// Returns the name of this expression as a string slice.
3058    pub fn get_name(&self) -> &str {
3059        match self {
3060            Expression::Identifier(id) => &id.name,
3061            Expression::Column(col) => &col.name.name,
3062            Expression::Table(t) => &t.name.name,
3063            Expression::Literal(lit) => lit.value_str(),
3064            Expression::Star(_) => "*",
3065            Expression::Function(f) => &f.name,
3066            Expression::AggregateFunction(f) => &f.name,
3067            Expression::Alias(a) => a.this.get_name(),
3068            Expression::Boolean(b) => {
3069                if b.value {
3070                    "TRUE"
3071                } else {
3072                    "FALSE"
3073                }
3074            }
3075            Expression::Null(_) => "NULL",
3076            _ => "",
3077        }
3078    }
3079
3080    /// Returns the alias name if this expression has one.
3081    pub fn get_alias(&self) -> &str {
3082        match self {
3083            Expression::Alias(a) => &a.alias.name,
3084            Expression::Table(t) => t.alias.as_ref().map(|a| a.name.as_str()).unwrap_or(""),
3085            Expression::Subquery(s) => s.alias.as_ref().map(|a| a.name.as_str()).unwrap_or(""),
3086            _ => "",
3087        }
3088    }
3089
3090    /// Returns the output name of this expression (what it shows up as in a SELECT).
3091    pub fn get_output_name(&self) -> &str {
3092        match self {
3093            Expression::Alias(a) => &a.alias.name,
3094            Expression::Column(c) => &c.name.name,
3095            Expression::Identifier(id) => &id.name,
3096            Expression::Literal(lit) => lit.value_str(),
3097            Expression::Subquery(s) => s.alias.as_ref().map(|a| a.name.as_str()).unwrap_or(""),
3098            Expression::Star(_) => "*",
3099            _ => "",
3100        }
3101    }
3102
3103    /// Returns comments attached to this expression.
3104    pub fn get_comments(&self) -> Vec<&str> {
3105        match self {
3106            Expression::Identifier(id) => id.trailing_comments.iter().map(|s| s.as_str()).collect(),
3107            Expression::Column(c) => c.trailing_comments.iter().map(|s| s.as_str()).collect(),
3108            Expression::Star(s) => s.trailing_comments.iter().map(|s| s.as_str()).collect(),
3109            Expression::Paren(p) => p.trailing_comments.iter().map(|s| s.as_str()).collect(),
3110            Expression::Annotated(a) => a.trailing_comments.iter().map(|s| s.as_str()).collect(),
3111            Expression::Alias(a) => a.trailing_comments.iter().map(|s| s.as_str()).collect(),
3112            Expression::Cast(c) | Expression::TryCast(c) | Expression::SafeCast(c) => {
3113                c.trailing_comments.iter().map(|s| s.as_str()).collect()
3114            }
3115            Expression::And(op)
3116            | Expression::Or(op)
3117            | Expression::Add(op)
3118            | Expression::Sub(op)
3119            | Expression::Mul(op)
3120            | Expression::Div(op)
3121            | Expression::Mod(op)
3122            | Expression::Eq(op)
3123            | Expression::Neq(op)
3124            | Expression::Lt(op)
3125            | Expression::Lte(op)
3126            | Expression::Gt(op)
3127            | Expression::Gte(op)
3128            | Expression::Concat(op)
3129            | Expression::BitwiseAnd(op)
3130            | Expression::BitwiseOr(op)
3131            | Expression::BitwiseXor(op) => {
3132                op.trailing_comments.iter().map(|s| s.as_str()).collect()
3133            }
3134            Expression::Function(f) => f.trailing_comments.iter().map(|s| s.as_str()).collect(),
3135            Expression::Subquery(s) => s.trailing_comments.iter().map(|s| s.as_str()).collect(),
3136            _ => Vec::new(),
3137        }
3138    }
3139}
3140
3141impl fmt::Display for Expression {
3142    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3143        // Basic display - full SQL generation is in generator module
3144        match self {
3145            Expression::Literal(lit) => write!(f, "{}", lit),
3146            Expression::Identifier(id) => write!(f, "{}", id),
3147            Expression::Column(col) => write!(f, "{}", col),
3148            Expression::Star(_) => write!(f, "*"),
3149            Expression::Null(_) => write!(f, "NULL"),
3150            Expression::Boolean(b) => write!(f, "{}", if b.value { "TRUE" } else { "FALSE" }),
3151            Expression::Select(_) => write!(f, "SELECT ..."),
3152            _ => write!(f, "{:?}", self),
3153        }
3154    }
3155}
3156
3157/// Represent a SQL literal value.
3158///
3159/// Numeric values are stored as their original text representation (not parsed
3160/// to `i64`/`f64`) so that precision, trailing zeros, and hex notation are
3161/// preserved across round-trips.
3162///
3163/// Dialect-specific literal forms (triple-quoted strings, dollar-quoted
3164/// strings, raw strings, etc.) each have a dedicated variant so that the
3165/// generator can emit them with the correct syntax.
3166#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3167#[cfg_attr(feature = "bindings", derive(TS))]
3168#[serde(tag = "literal_type", content = "value", rename_all = "snake_case")]
3169pub enum Literal {
3170    /// Single-quoted string literal: `'hello'`
3171    String(String),
3172    /// Numeric literal, stored as the original text: `42`, `3.14`, `1e10`
3173    Number(String),
3174    /// Hex string literal: `X'FF'`
3175    HexString(String),
3176    /// Hex number: 0xA, 0xFF (BigQuery, SQLite style) - represents an integer in hex notation
3177    HexNumber(String),
3178    BitString(String),
3179    /// Byte string: b"..." (BigQuery style)
3180    ByteString(String),
3181    /// National string: N'abc'
3182    NationalString(String),
3183    /// DATE literal: DATE '2024-01-15'
3184    Date(String),
3185    /// TIME literal: TIME '10:30:00'
3186    Time(String),
3187    /// TIMESTAMP literal: TIMESTAMP '2024-01-15 10:30:00'
3188    Timestamp(String),
3189    /// DATETIME literal: DATETIME '2024-01-15 10:30:00' (BigQuery)
3190    Datetime(String),
3191    /// Triple-quoted string: """...""" or '''...'''
3192    /// Contains (content, quote_char) where quote_char is '"' or '\''
3193    TripleQuotedString(String, char),
3194    /// Escape string: E'...' (PostgreSQL)
3195    EscapeString(String),
3196    /// Dollar-quoted string: $$...$$  (PostgreSQL)
3197    DollarString(String),
3198    /// Raw string: r"..." or r'...' (BigQuery, Spark, Databricks)
3199    /// In raw strings, backslashes are literal and not escape characters.
3200    /// When converting to a regular string, backslashes must be doubled.
3201    RawString(String),
3202}
3203
3204impl Literal {
3205    /// Returns the inner value as a string slice, regardless of literal type.
3206    pub fn value_str(&self) -> &str {
3207        match self {
3208            Literal::String(s)
3209            | Literal::Number(s)
3210            | Literal::HexString(s)
3211            | Literal::HexNumber(s)
3212            | Literal::BitString(s)
3213            | Literal::ByteString(s)
3214            | Literal::NationalString(s)
3215            | Literal::Date(s)
3216            | Literal::Time(s)
3217            | Literal::Timestamp(s)
3218            | Literal::Datetime(s)
3219            | Literal::EscapeString(s)
3220            | Literal::DollarString(s)
3221            | Literal::RawString(s) => s.as_str(),
3222            Literal::TripleQuotedString(s, _) => s.as_str(),
3223        }
3224    }
3225
3226    /// Returns `true` if this is a string-type literal.
3227    pub fn is_string(&self) -> bool {
3228        matches!(
3229            self,
3230            Literal::String(_)
3231                | Literal::NationalString(_)
3232                | Literal::EscapeString(_)
3233                | Literal::DollarString(_)
3234                | Literal::RawString(_)
3235                | Literal::TripleQuotedString(_, _)
3236        )
3237    }
3238
3239    /// Returns `true` if this is a numeric literal.
3240    pub fn is_number(&self) -> bool {
3241        matches!(self, Literal::Number(_) | Literal::HexNumber(_))
3242    }
3243}
3244
3245impl fmt::Display for Literal {
3246    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3247        match self {
3248            Literal::String(s) => write!(f, "'{}'", s),
3249            Literal::Number(n) => write!(f, "{}", n),
3250            Literal::HexString(h) => write!(f, "X'{}'", h),
3251            Literal::HexNumber(h) => write!(f, "0x{}", h),
3252            Literal::BitString(b) => write!(f, "B'{}'", b),
3253            Literal::ByteString(b) => write!(f, "b'{}'", b),
3254            Literal::NationalString(s) => write!(f, "N'{}'", s),
3255            Literal::Date(d) => write!(f, "DATE '{}'", d),
3256            Literal::Time(t) => write!(f, "TIME '{}'", t),
3257            Literal::Timestamp(ts) => write!(f, "TIMESTAMP '{}'", ts),
3258            Literal::Datetime(dt) => write!(f, "DATETIME '{}'", dt),
3259            Literal::TripleQuotedString(s, q) => {
3260                write!(f, "{0}{0}{0}{1}{0}{0}{0}", q, s)
3261            }
3262            Literal::EscapeString(s) => write!(f, "E'{}'", s),
3263            Literal::DollarString(s) => write!(f, "$${}$$", s),
3264            Literal::RawString(s) => write!(f, "r'{}'", s),
3265        }
3266    }
3267}
3268
3269/// Boolean literal
3270#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3271#[cfg_attr(feature = "bindings", derive(TS))]
3272pub struct BooleanLiteral {
3273    pub value: bool,
3274}
3275
3276/// NULL literal
3277#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3278#[cfg_attr(feature = "bindings", derive(TS))]
3279pub struct Null;
3280
3281/// Represent a SQL identifier (table name, column name, alias, keyword-as-name, etc.).
3282///
3283/// The `quoted` flag indicates whether the identifier was originally delimited
3284/// (double-quoted, backtick-quoted, or bracket-quoted depending on the
3285/// dialect). The generator uses this flag to decide whether to emit quoting
3286/// characters.
3287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3288#[cfg_attr(feature = "bindings", derive(TS))]
3289pub struct Identifier {
3290    /// The raw text of the identifier, without any quoting characters.
3291    pub name: String,
3292    /// Whether the identifier was quoted in the source SQL.
3293    pub quoted: bool,
3294    #[serde(default)]
3295    pub trailing_comments: Vec<String>,
3296    /// Source position span (populated during parsing, None for programmatically constructed nodes)
3297    #[serde(default, skip_serializing_if = "Option::is_none")]
3298    pub span: Option<Span>,
3299}
3300
3301impl Identifier {
3302    pub fn new(name: impl Into<String>) -> Self {
3303        Self {
3304            name: name.into(),
3305            quoted: false,
3306            trailing_comments: Vec::new(),
3307            span: None,
3308        }
3309    }
3310
3311    pub fn quoted(name: impl Into<String>) -> Self {
3312        Self {
3313            name: name.into(),
3314            quoted: true,
3315            trailing_comments: Vec::new(),
3316            span: None,
3317        }
3318    }
3319
3320    pub fn empty() -> Self {
3321        Self {
3322            name: String::new(),
3323            quoted: false,
3324            trailing_comments: Vec::new(),
3325            span: None,
3326        }
3327    }
3328
3329    pub fn is_empty(&self) -> bool {
3330        self.name.is_empty()
3331    }
3332
3333    /// Set the source span on this identifier
3334    pub fn with_span(mut self, span: Span) -> Self {
3335        self.span = Some(span);
3336        self
3337    }
3338}
3339
3340impl fmt::Display for Identifier {
3341    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3342        if self.quoted {
3343            write!(f, "\"{}\"", self.name)
3344        } else {
3345            write!(f, "{}", self.name)
3346        }
3347    }
3348}
3349
3350/// Represent a column reference, optionally qualified by a table name.
3351///
3352/// Renders as `name` when unqualified, or `table.name` when qualified.
3353/// Use [`Expression::column()`] or [`Expression::qualified_column()`] for
3354/// convenient construction.
3355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3356#[cfg_attr(feature = "bindings", derive(TS))]
3357pub struct Column {
3358    /// The column name.
3359    pub name: Identifier,
3360    /// Optional table qualifier (e.g. `t` in `t.col`).
3361    pub table: Option<Identifier>,
3362    /// Oracle-style join marker (+) for outer joins
3363    #[serde(default)]
3364    pub join_mark: bool,
3365    /// Trailing comments that appeared after this column reference
3366    #[serde(default)]
3367    pub trailing_comments: Vec<String>,
3368    /// Source position span
3369    #[serde(default, skip_serializing_if = "Option::is_none")]
3370    pub span: Option<Span>,
3371    /// Inferred data type from type annotation
3372    #[serde(default, skip_serializing_if = "Option::is_none")]
3373    pub inferred_type: Option<DataType>,
3374}
3375
3376impl fmt::Display for Column {
3377    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3378        if let Some(table) = &self.table {
3379            write!(f, "{}.{}", table, self.name)
3380        } else {
3381            write!(f, "{}", self.name)
3382        }
3383    }
3384}
3385
3386/// Represent a table reference with optional schema and catalog qualifiers.
3387///
3388/// Renders as `name`, `schema.name`, or `catalog.schema.name` depending on
3389/// which qualifiers are present. Supports aliases, column alias lists,
3390/// time-travel clauses (Snowflake, BigQuery), table hints (TSQL), and
3391/// several other dialect-specific extensions.
3392#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3393#[cfg_attr(feature = "bindings", derive(TS))]
3394pub struct TableRef {
3395    /// The unqualified table name.
3396    pub name: Identifier,
3397    /// Optional schema qualifier (e.g. `public` in `public.users`).
3398    pub schema: Option<Identifier>,
3399    /// Optional catalog qualifier (e.g. `mydb` in `mydb.public.users`).
3400    pub catalog: Option<Identifier>,
3401    /// Optional table alias (e.g. `t` in `FROM users AS t`).
3402    pub alias: Option<Identifier>,
3403    /// Whether AS keyword was explicitly used for the alias
3404    #[serde(default)]
3405    pub alias_explicit_as: bool,
3406    /// Column aliases for table alias: AS t(c1, c2)
3407    #[serde(default)]
3408    pub column_aliases: Vec<Identifier>,
3409    /// Leading comments that appeared before this table reference in a FROM clause
3410    #[serde(default, skip_serializing_if = "Vec::is_empty")]
3411    pub leading_comments: Vec<String>,
3412    /// Trailing comments that appeared after this table reference
3413    #[serde(default)]
3414    pub trailing_comments: Vec<String>,
3415    /// Snowflake time travel: BEFORE (STATEMENT => ...) or AT (TIMESTAMP => ...)
3416    #[serde(default)]
3417    pub when: Option<Box<HistoricalData>>,
3418    /// PostgreSQL ONLY modifier: prevents scanning child tables in inheritance hierarchy
3419    #[serde(default)]
3420    pub only: bool,
3421    /// ClickHouse FINAL modifier: forces final aggregation for MergeTree tables
3422    #[serde(default)]
3423    pub final_: bool,
3424    /// TABLESAMPLE clause attached to this table reference (DuckDB, BigQuery)
3425    #[serde(default, skip_serializing_if = "Option::is_none")]
3426    pub table_sample: Option<Box<Sample>>,
3427    /// TSQL table hints: WITH (TABLOCK, INDEX(myindex), ...)
3428    #[serde(default)]
3429    pub hints: Vec<Expression>,
3430    /// TSQL: FOR SYSTEM_TIME temporal clause
3431    /// Contains the full clause text, e.g., "FOR SYSTEM_TIME BETWEEN c AND d"
3432    #[serde(default, skip_serializing_if = "Option::is_none")]
3433    pub system_time: Option<String>,
3434    /// MySQL: PARTITION(p0, p1, ...) hint for reading from specific partitions
3435    #[serde(default, skip_serializing_if = "Vec::is_empty")]
3436    pub partitions: Vec<Identifier>,
3437    /// Snowflake IDENTIFIER() function: dynamic table name from string/variable
3438    /// When set, this is used instead of the name field
3439    #[serde(default, skip_serializing_if = "Option::is_none")]
3440    pub identifier_func: Option<Box<Expression>>,
3441    /// Snowflake CHANGES clause: CHANGES (INFORMATION => ...) AT (...) END (...)
3442    #[serde(default, skip_serializing_if = "Option::is_none")]
3443    pub changes: Option<Box<Changes>>,
3444    /// Time travel version clause: FOR VERSION AS OF / FOR TIMESTAMP AS OF (Presto/Trino, BigQuery, Databricks)
3445    #[serde(default, skip_serializing_if = "Option::is_none")]
3446    pub version: Option<Box<Version>>,
3447    /// Source position span
3448    #[serde(default, skip_serializing_if = "Option::is_none")]
3449    pub span: Option<Span>,
3450}
3451
3452impl TableRef {
3453    pub fn new(name: impl Into<String>) -> Self {
3454        Self {
3455            name: Identifier::new(name),
3456            schema: None,
3457            catalog: None,
3458            alias: None,
3459            alias_explicit_as: false,
3460            column_aliases: Vec::new(),
3461            leading_comments: Vec::new(),
3462            trailing_comments: Vec::new(),
3463            when: None,
3464            only: false,
3465            final_: false,
3466            table_sample: None,
3467            hints: Vec::new(),
3468            system_time: None,
3469            partitions: Vec::new(),
3470            identifier_func: None,
3471            changes: None,
3472            version: None,
3473            span: None,
3474        }
3475    }
3476
3477    /// Create with a schema qualifier.
3478    pub fn new_with_schema(name: impl Into<String>, schema: impl Into<String>) -> Self {
3479        let mut t = Self::new(name);
3480        t.schema = Some(Identifier::new(schema));
3481        t
3482    }
3483
3484    /// Create with catalog and schema qualifiers.
3485    pub fn new_with_catalog(
3486        name: impl Into<String>,
3487        schema: impl Into<String>,
3488        catalog: impl Into<String>,
3489    ) -> Self {
3490        let mut t = Self::new(name);
3491        t.schema = Some(Identifier::new(schema));
3492        t.catalog = Some(Identifier::new(catalog));
3493        t
3494    }
3495
3496    /// Create from an Identifier, preserving the quoted flag
3497    pub fn from_identifier(name: Identifier) -> Self {
3498        Self {
3499            name,
3500            schema: None,
3501            catalog: None,
3502            alias: None,
3503            alias_explicit_as: false,
3504            column_aliases: Vec::new(),
3505            leading_comments: Vec::new(),
3506            trailing_comments: Vec::new(),
3507            when: None,
3508            only: false,
3509            final_: false,
3510            table_sample: None,
3511            hints: Vec::new(),
3512            system_time: None,
3513            partitions: Vec::new(),
3514            identifier_func: None,
3515            changes: None,
3516            version: None,
3517            span: None,
3518        }
3519    }
3520
3521    pub fn with_alias(mut self, alias: impl Into<String>) -> Self {
3522        self.alias = Some(Identifier::new(alias));
3523        self
3524    }
3525
3526    pub fn with_schema(mut self, schema: impl Into<String>) -> Self {
3527        self.schema = Some(Identifier::new(schema));
3528        self
3529    }
3530}
3531
3532/// Represent a wildcard star expression (`*`, `table.*`).
3533///
3534/// Supports the EXCEPT/EXCLUDE, REPLACE, and RENAME modifiers found in
3535/// DuckDB, BigQuery, and Snowflake (e.g. `SELECT * EXCEPT (id) FROM t`).
3536#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3537#[cfg_attr(feature = "bindings", derive(TS))]
3538pub struct Star {
3539    /// Optional table qualifier (e.g. `t` in `t.*`).
3540    pub table: Option<Identifier>,
3541    /// EXCLUDE / EXCEPT columns (DuckDB, BigQuery, Snowflake)
3542    pub except: Option<Vec<Identifier>>,
3543    /// REPLACE expressions (BigQuery, Snowflake)
3544    pub replace: Option<Vec<Alias>>,
3545    /// RENAME columns (Snowflake)
3546    pub rename: Option<Vec<(Identifier, Identifier)>>,
3547    /// Trailing comments that appeared after the star
3548    #[serde(default, skip_serializing_if = "Vec::is_empty")]
3549    pub trailing_comments: Vec<String>,
3550    /// Source position span
3551    #[serde(default, skip_serializing_if = "Option::is_none")]
3552    pub span: Option<Span>,
3553}
3554
3555/// Represent a complete SELECT statement.
3556///
3557/// This is the most feature-rich AST node, covering the full surface area of
3558/// SELECT syntax across 30+ SQL dialects. Fields that are `Option` or empty
3559/// `Vec` are omitted from the generated SQL when absent.
3560///
3561/// # Key Fields
3562///
3563/// - `expressions` -- the select-list (columns, `*`, computed expressions).
3564/// - `from` -- the FROM clause. `None` for `SELECT 1` style queries.
3565/// - `joins` -- zero or more JOIN clauses, each with a [`JoinKind`].
3566/// - `where_clause` -- the WHERE predicate.
3567/// - `group_by` -- GROUP BY, including ROLLUP/CUBE/GROUPING SETS.
3568/// - `having` -- HAVING predicate.
3569/// - `order_by` -- ORDER BY with ASC/DESC and NULLS FIRST/LAST.
3570/// - `limit` / `offset` / `fetch` -- result set limiting.
3571/// - `with` -- Common Table Expressions (CTEs).
3572/// - `distinct` / `distinct_on` -- DISTINCT and PostgreSQL DISTINCT ON.
3573/// - `windows` -- named window definitions (WINDOW w AS ...).
3574///
3575/// Dialect-specific extensions are supported via fields like `prewhere`
3576/// (ClickHouse), `qualify` (Snowflake/BigQuery/DuckDB), `connect` (Oracle
3577/// CONNECT BY), `for_xml` (TSQL), and `settings` (ClickHouse).
3578#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3579#[cfg_attr(feature = "bindings", derive(TS))]
3580pub struct Select {
3581    /// The select-list: columns, expressions, aliases, and wildcards.
3582    pub expressions: Vec<Expression>,
3583    /// The FROM clause, containing one or more table sources.
3584    pub from: Option<From>,
3585    /// JOIN clauses applied after the FROM source.
3586    pub joins: Vec<Join>,
3587    pub lateral_views: Vec<LateralView>,
3588    /// ClickHouse PREWHERE clause
3589    #[serde(default, skip_serializing_if = "Option::is_none")]
3590    pub prewhere: Option<Expression>,
3591    pub where_clause: Option<Where>,
3592    pub group_by: Option<GroupBy>,
3593    pub having: Option<Having>,
3594    pub qualify: Option<Qualify>,
3595    pub order_by: Option<OrderBy>,
3596    pub distribute_by: Option<DistributeBy>,
3597    pub cluster_by: Option<ClusterBy>,
3598    pub sort_by: Option<SortBy>,
3599    pub limit: Option<Limit>,
3600    pub offset: Option<Offset>,
3601    /// ClickHouse LIMIT BY clause expressions
3602    #[serde(default, skip_serializing_if = "Option::is_none")]
3603    pub limit_by: Option<Vec<Expression>>,
3604    pub fetch: Option<Fetch>,
3605    pub distinct: bool,
3606    pub distinct_on: Option<Vec<Expression>>,
3607    pub top: Option<Top>,
3608    pub with: Option<With>,
3609    pub sample: Option<Sample>,
3610    /// ClickHouse SETTINGS clause (e.g., SETTINGS max_threads = 4)
3611    #[serde(default, skip_serializing_if = "Option::is_none")]
3612    pub settings: Option<Vec<Expression>>,
3613    /// ClickHouse FORMAT clause (e.g., FORMAT PrettyCompact)
3614    #[serde(default, skip_serializing_if = "Option::is_none")]
3615    pub format: Option<Expression>,
3616    pub windows: Option<Vec<NamedWindow>>,
3617    pub hint: Option<Hint>,
3618    /// Oracle CONNECT BY clause for hierarchical queries
3619    pub connect: Option<Connect>,
3620    /// SELECT ... INTO table_name for creating tables
3621    pub into: Option<SelectInto>,
3622    /// FOR UPDATE/SHARE locking clauses
3623    #[serde(default)]
3624    pub locks: Vec<Lock>,
3625    /// T-SQL FOR XML clause options (PATH, RAW, AUTO, EXPLICIT, BINARY BASE64, ELEMENTS XSINIL, etc.)
3626    #[serde(default, skip_serializing_if = "Vec::is_empty")]
3627    pub for_xml: Vec<Expression>,
3628    /// Leading comments before the statement
3629    #[serde(default)]
3630    pub leading_comments: Vec<String>,
3631    /// Comments that appear after SELECT keyword (before expressions)
3632    /// Example: `SELECT <comment> col` -> `post_select_comments: ["<comment>"]`
3633    #[serde(default, skip_serializing_if = "Vec::is_empty")]
3634    pub post_select_comments: Vec<String>,
3635    /// BigQuery SELECT AS STRUCT / SELECT AS VALUE kind
3636    #[serde(default, skip_serializing_if = "Option::is_none")]
3637    pub kind: Option<String>,
3638    /// MySQL operation modifiers (HIGH_PRIORITY, STRAIGHT_JOIN, SQL_CALC_FOUND_ROWS, etc.)
3639    #[serde(default, skip_serializing_if = "Vec::is_empty")]
3640    pub operation_modifiers: Vec<String>,
3641    /// Whether QUALIFY appears after WINDOW (DuckDB) vs before (Snowflake/BigQuery default)
3642    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
3643    pub qualify_after_window: bool,
3644    /// TSQL OPTION clause (e.g., OPTION(LABEL = 'foo'))
3645    #[serde(default, skip_serializing_if = "Option::is_none")]
3646    pub option: Option<String>,
3647    /// Redshift-style EXCLUDE clause at the end of the projection list
3648    /// e.g., SELECT *, 4 AS col4 EXCLUDE (col2, col3) FROM ...
3649    #[serde(default, skip_serializing_if = "Option::is_none")]
3650    pub exclude: Option<Vec<Expression>>,
3651}
3652
3653impl Select {
3654    pub fn new() -> Self {
3655        Self {
3656            expressions: Vec::new(),
3657            from: None,
3658            joins: Vec::new(),
3659            lateral_views: Vec::new(),
3660            prewhere: None,
3661            where_clause: None,
3662            group_by: None,
3663            having: None,
3664            qualify: None,
3665            order_by: None,
3666            distribute_by: None,
3667            cluster_by: None,
3668            sort_by: None,
3669            limit: None,
3670            offset: None,
3671            limit_by: None,
3672            fetch: None,
3673            distinct: false,
3674            distinct_on: None,
3675            top: None,
3676            with: None,
3677            sample: None,
3678            settings: None,
3679            format: None,
3680            windows: None,
3681            hint: None,
3682            connect: None,
3683            into: None,
3684            locks: Vec::new(),
3685            for_xml: Vec::new(),
3686            leading_comments: Vec::new(),
3687            post_select_comments: Vec::new(),
3688            kind: None,
3689            operation_modifiers: Vec::new(),
3690            qualify_after_window: false,
3691            option: None,
3692            exclude: None,
3693        }
3694    }
3695
3696    /// Add a column to select
3697    pub fn column(mut self, expr: Expression) -> Self {
3698        self.expressions.push(expr);
3699        self
3700    }
3701
3702    /// Set the FROM clause
3703    pub fn from(mut self, table: Expression) -> Self {
3704        self.from = Some(From {
3705            expressions: vec![table],
3706        });
3707        self
3708    }
3709
3710    /// Add a WHERE clause
3711    pub fn where_(mut self, condition: Expression) -> Self {
3712        self.where_clause = Some(Where { this: condition });
3713        self
3714    }
3715
3716    /// Set DISTINCT
3717    pub fn distinct(mut self) -> Self {
3718        self.distinct = true;
3719        self
3720    }
3721
3722    /// Add a JOIN
3723    pub fn join(mut self, join: Join) -> Self {
3724        self.joins.push(join);
3725        self
3726    }
3727
3728    /// Set ORDER BY
3729    pub fn order_by(mut self, expressions: Vec<Ordered>) -> Self {
3730        self.order_by = Some(OrderBy {
3731            expressions,
3732            siblings: false,
3733            comments: Vec::new(),
3734        });
3735        self
3736    }
3737
3738    /// Set LIMIT
3739    pub fn limit(mut self, n: Expression) -> Self {
3740        self.limit = Some(Limit {
3741            this: n,
3742            percent: false,
3743            comments: Vec::new(),
3744        });
3745        self
3746    }
3747
3748    /// Set OFFSET
3749    pub fn offset(mut self, n: Expression) -> Self {
3750        self.offset = Some(Offset {
3751            this: n,
3752            rows: None,
3753        });
3754        self
3755    }
3756}
3757
3758impl Default for Select {
3759    fn default() -> Self {
3760        Self::new()
3761    }
3762}
3763
3764/// Represent a UNION set operation between two query expressions.
3765///
3766/// When `all` is true, duplicate rows are preserved (UNION ALL).
3767/// ORDER BY, LIMIT, and OFFSET can be applied to the combined result.
3768/// Supports DuckDB's BY NAME modifier and BigQuery's CORRESPONDING modifier.
3769#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3770#[cfg_attr(feature = "bindings", derive(TS))]
3771pub struct Union {
3772    /// The left-hand query operand.
3773    pub left: Expression,
3774    /// The right-hand query operand.
3775    pub right: Expression,
3776    /// Whether UNION ALL (true) or UNION (false, which deduplicates).
3777    pub all: bool,
3778    /// Whether DISTINCT was explicitly specified
3779    #[serde(default)]
3780    pub distinct: bool,
3781    /// Optional WITH clause
3782    pub with: Option<With>,
3783    /// ORDER BY applied to entire UNION result
3784    pub order_by: Option<OrderBy>,
3785    /// LIMIT applied to entire UNION result
3786    pub limit: Option<Box<Expression>>,
3787    /// OFFSET applied to entire UNION result
3788    pub offset: Option<Box<Expression>>,
3789    /// DISTRIBUTE BY clause (Hive/Spark)
3790    #[serde(default, skip_serializing_if = "Option::is_none")]
3791    pub distribute_by: Option<DistributeBy>,
3792    /// SORT BY clause (Hive/Spark)
3793    #[serde(default, skip_serializing_if = "Option::is_none")]
3794    pub sort_by: Option<SortBy>,
3795    /// CLUSTER BY clause (Hive/Spark)
3796    #[serde(default, skip_serializing_if = "Option::is_none")]
3797    pub cluster_by: Option<ClusterBy>,
3798    /// DuckDB BY NAME modifier
3799    #[serde(default)]
3800    pub by_name: bool,
3801    /// BigQuery: Set operation side (LEFT, RIGHT, FULL)
3802    #[serde(default, skip_serializing_if = "Option::is_none")]
3803    pub side: Option<String>,
3804    /// BigQuery: Set operation kind (INNER)
3805    #[serde(default, skip_serializing_if = "Option::is_none")]
3806    pub kind: Option<String>,
3807    /// BigQuery: CORRESPONDING modifier
3808    #[serde(default)]
3809    pub corresponding: bool,
3810    /// BigQuery: STRICT modifier (before CORRESPONDING)
3811    #[serde(default)]
3812    pub strict: bool,
3813    /// BigQuery: BY (columns) after CORRESPONDING
3814    #[serde(default, skip_serializing_if = "Vec::is_empty")]
3815    pub on_columns: Vec<Expression>,
3816}
3817
3818/// Iteratively flatten the left-recursive chain to prevent stack overflow
3819/// when dropping deeply nested set operation trees (e.g., 1000+ UNION ALLs).
3820impl Drop for Union {
3821    fn drop(&mut self) {
3822        loop {
3823            if let Expression::Union(ref mut inner) = self.left {
3824                let next_left = std::mem::replace(&mut inner.left, Expression::Null(Null));
3825                let old_left = std::mem::replace(&mut self.left, next_left);
3826                drop(old_left);
3827            } else {
3828                break;
3829            }
3830        }
3831    }
3832}
3833
3834/// Represent an INTERSECT set operation between two query expressions.
3835///
3836/// Returns only rows that appear in both operands. When `all` is true,
3837/// duplicates are preserved according to their multiplicity.
3838#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3839#[cfg_attr(feature = "bindings", derive(TS))]
3840pub struct Intersect {
3841    /// The left-hand query operand.
3842    pub left: Expression,
3843    /// The right-hand query operand.
3844    pub right: Expression,
3845    /// Whether INTERSECT ALL (true) or INTERSECT (false, which deduplicates).
3846    pub all: bool,
3847    /// Whether DISTINCT was explicitly specified
3848    #[serde(default)]
3849    pub distinct: bool,
3850    /// Optional WITH clause
3851    pub with: Option<With>,
3852    /// ORDER BY applied to entire INTERSECT result
3853    pub order_by: Option<OrderBy>,
3854    /// LIMIT applied to entire INTERSECT result
3855    pub limit: Option<Box<Expression>>,
3856    /// OFFSET applied to entire INTERSECT result
3857    pub offset: Option<Box<Expression>>,
3858    /// DISTRIBUTE BY clause (Hive/Spark)
3859    #[serde(default, skip_serializing_if = "Option::is_none")]
3860    pub distribute_by: Option<DistributeBy>,
3861    /// SORT BY clause (Hive/Spark)
3862    #[serde(default, skip_serializing_if = "Option::is_none")]
3863    pub sort_by: Option<SortBy>,
3864    /// CLUSTER BY clause (Hive/Spark)
3865    #[serde(default, skip_serializing_if = "Option::is_none")]
3866    pub cluster_by: Option<ClusterBy>,
3867    /// DuckDB BY NAME modifier
3868    #[serde(default)]
3869    pub by_name: bool,
3870    /// BigQuery: Set operation side (LEFT, RIGHT, FULL)
3871    #[serde(default, skip_serializing_if = "Option::is_none")]
3872    pub side: Option<String>,
3873    /// BigQuery: Set operation kind (INNER)
3874    #[serde(default, skip_serializing_if = "Option::is_none")]
3875    pub kind: Option<String>,
3876    /// BigQuery: CORRESPONDING modifier
3877    #[serde(default)]
3878    pub corresponding: bool,
3879    /// BigQuery: STRICT modifier (before CORRESPONDING)
3880    #[serde(default)]
3881    pub strict: bool,
3882    /// BigQuery: BY (columns) after CORRESPONDING
3883    #[serde(default, skip_serializing_if = "Vec::is_empty")]
3884    pub on_columns: Vec<Expression>,
3885}
3886
3887impl Drop for Intersect {
3888    fn drop(&mut self) {
3889        loop {
3890            if let Expression::Intersect(ref mut inner) = self.left {
3891                let next_left = std::mem::replace(&mut inner.left, Expression::Null(Null));
3892                let old_left = std::mem::replace(&mut self.left, next_left);
3893                drop(old_left);
3894            } else {
3895                break;
3896            }
3897        }
3898    }
3899}
3900
3901/// Represent an EXCEPT (MINUS) set operation between two query expressions.
3902///
3903/// Returns rows from the left operand that do not appear in the right operand.
3904/// When `all` is true, duplicates are subtracted according to their multiplicity.
3905#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3906#[cfg_attr(feature = "bindings", derive(TS))]
3907pub struct Except {
3908    /// The left-hand query operand.
3909    pub left: Expression,
3910    /// The right-hand query operand (rows to subtract).
3911    pub right: Expression,
3912    /// Whether EXCEPT ALL (true) or EXCEPT (false, which deduplicates).
3913    pub all: bool,
3914    /// Whether DISTINCT was explicitly specified
3915    #[serde(default)]
3916    pub distinct: bool,
3917    /// Optional WITH clause
3918    pub with: Option<With>,
3919    /// ORDER BY applied to entire EXCEPT result
3920    pub order_by: Option<OrderBy>,
3921    /// LIMIT applied to entire EXCEPT result
3922    pub limit: Option<Box<Expression>>,
3923    /// OFFSET applied to entire EXCEPT result
3924    pub offset: Option<Box<Expression>>,
3925    /// DISTRIBUTE BY clause (Hive/Spark)
3926    #[serde(default, skip_serializing_if = "Option::is_none")]
3927    pub distribute_by: Option<DistributeBy>,
3928    /// SORT BY clause (Hive/Spark)
3929    #[serde(default, skip_serializing_if = "Option::is_none")]
3930    pub sort_by: Option<SortBy>,
3931    /// CLUSTER BY clause (Hive/Spark)
3932    #[serde(default, skip_serializing_if = "Option::is_none")]
3933    pub cluster_by: Option<ClusterBy>,
3934    /// DuckDB BY NAME modifier
3935    #[serde(default)]
3936    pub by_name: bool,
3937    /// BigQuery: Set operation side (LEFT, RIGHT, FULL)
3938    #[serde(default, skip_serializing_if = "Option::is_none")]
3939    pub side: Option<String>,
3940    /// BigQuery: Set operation kind (INNER)
3941    #[serde(default, skip_serializing_if = "Option::is_none")]
3942    pub kind: Option<String>,
3943    /// BigQuery: CORRESPONDING modifier
3944    #[serde(default)]
3945    pub corresponding: bool,
3946    /// BigQuery: STRICT modifier (before CORRESPONDING)
3947    #[serde(default)]
3948    pub strict: bool,
3949    /// BigQuery: BY (columns) after CORRESPONDING
3950    #[serde(default, skip_serializing_if = "Vec::is_empty")]
3951    pub on_columns: Vec<Expression>,
3952}
3953
3954impl Drop for Except {
3955    fn drop(&mut self) {
3956        loop {
3957            if let Expression::Except(ref mut inner) = self.left {
3958                let next_left = std::mem::replace(&mut inner.left, Expression::Null(Null));
3959                let old_left = std::mem::replace(&mut self.left, next_left);
3960                drop(old_left);
3961            } else {
3962                break;
3963            }
3964        }
3965    }
3966}
3967
3968/// INTO clause for SELECT INTO statements
3969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3970#[cfg_attr(feature = "bindings", derive(TS))]
3971pub struct SelectInto {
3972    /// Target table or variable (used when single target)
3973    pub this: Expression,
3974    /// Whether TEMPORARY keyword was used
3975    #[serde(default)]
3976    pub temporary: bool,
3977    /// Whether UNLOGGED keyword was used (PostgreSQL)
3978    #[serde(default)]
3979    pub unlogged: bool,
3980    /// Whether BULK COLLECT INTO was used (Oracle PL/SQL)
3981    #[serde(default)]
3982    pub bulk_collect: bool,
3983    /// Multiple target variables (Oracle PL/SQL: BULK COLLECT INTO v1, v2)
3984    #[serde(default, skip_serializing_if = "Vec::is_empty")]
3985    pub expressions: Vec<Expression>,
3986}
3987
3988/// Represent a parenthesized subquery expression.
3989///
3990/// A subquery wraps an inner query (typically a SELECT, UNION, etc.) in
3991/// parentheses and optionally applies an alias, column aliases, ORDER BY,
3992/// LIMIT, and OFFSET. The `modifiers_inside` flag controls whether the
3993/// modifiers are rendered inside or outside the parentheses.
3994///
3995/// Subqueries appear in many SQL contexts: FROM clauses, WHERE IN/EXISTS,
3996/// scalar subqueries in select-lists, and derived tables.
3997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3998#[cfg_attr(feature = "bindings", derive(TS))]
3999pub struct Subquery {
4000    /// The inner query expression.
4001    pub this: Expression,
4002    /// Optional alias for the derived table.
4003    pub alias: Option<Identifier>,
4004    /// Optional column aliases: AS t(c1, c2)
4005    pub column_aliases: Vec<Identifier>,
4006    /// ORDER BY clause (for parenthesized queries)
4007    pub order_by: Option<OrderBy>,
4008    /// LIMIT clause
4009    pub limit: Option<Limit>,
4010    /// OFFSET clause
4011    pub offset: Option<Offset>,
4012    /// DISTRIBUTE BY clause (Hive/Spark)
4013    #[serde(default, skip_serializing_if = "Option::is_none")]
4014    pub distribute_by: Option<DistributeBy>,
4015    /// SORT BY clause (Hive/Spark)
4016    #[serde(default, skip_serializing_if = "Option::is_none")]
4017    pub sort_by: Option<SortBy>,
4018    /// CLUSTER BY clause (Hive/Spark)
4019    #[serde(default, skip_serializing_if = "Option::is_none")]
4020    pub cluster_by: Option<ClusterBy>,
4021    /// Whether this is a LATERAL subquery (can reference earlier tables in FROM)
4022    #[serde(default)]
4023    pub lateral: bool,
4024    /// Whether modifiers (ORDER BY, LIMIT, OFFSET) should be generated inside the parentheses
4025    /// true: (SELECT 1 LIMIT 1)  - modifiers inside
4026    /// false: (SELECT 1) LIMIT 1 - modifiers outside
4027    #[serde(default)]
4028    pub modifiers_inside: bool,
4029    /// Trailing comments after the closing paren
4030    #[serde(default)]
4031    pub trailing_comments: Vec<String>,
4032    /// Inferred data type from type annotation
4033    #[serde(default, skip_serializing_if = "Option::is_none")]
4034    pub inferred_type: Option<DataType>,
4035}
4036
4037/// Pipe operator expression: query |> transform
4038///
4039/// Used in DataFusion and BigQuery pipe syntax:
4040///   FROM t |> WHERE x > 1 |> SELECT x, y |> ORDER BY x |> LIMIT 10
4041#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4042#[cfg_attr(feature = "bindings", derive(TS))]
4043pub struct PipeOperator {
4044    /// The input query/expression (left side of |>)
4045    pub this: Expression,
4046    /// The piped operation (right side of |>)
4047    pub expression: Expression,
4048}
4049
4050/// VALUES table constructor: VALUES (1, 'a'), (2, 'b')
4051#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4052#[cfg_attr(feature = "bindings", derive(TS))]
4053pub struct Values {
4054    /// The rows of values
4055    pub expressions: Vec<Tuple>,
4056    /// Optional alias for the table
4057    pub alias: Option<Identifier>,
4058    /// Optional column aliases: AS t(c1, c2)
4059    pub column_aliases: Vec<Identifier>,
4060}
4061
4062/// PIVOT operation - supports both standard and DuckDB simplified syntax
4063///
4064/// Standard syntax (in FROM clause):
4065///   table PIVOT(agg_func [AS alias], ... FOR column IN (value [AS alias], ...))
4066///   table UNPIVOT(value_col FOR name_col IN (col1, col2, ...))
4067///
4068/// DuckDB simplified syntax (statement-level):
4069///   PIVOT table ON columns [IN (...)] USING agg_func [AS alias], ... [GROUP BY ...]
4070///   UNPIVOT table ON columns INTO NAME name_col VALUE val_col
4071#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4072#[cfg_attr(feature = "bindings", derive(TS))]
4073pub struct Pivot {
4074    /// Source table/expression
4075    pub this: Expression,
4076    /// For standard PIVOT: the aggregation function(s) (first is primary)
4077    /// For DuckDB simplified: unused (use `using` instead)
4078    #[serde(default)]
4079    pub expressions: Vec<Expression>,
4080    /// For standard PIVOT: the FOR...IN clause(s) as In expressions
4081    #[serde(default)]
4082    pub fields: Vec<Expression>,
4083    /// For standard: unused. For DuckDB simplified: the USING aggregation functions
4084    #[serde(default)]
4085    pub using: Vec<Expression>,
4086    /// GROUP BY clause (used in both standard inside-parens and DuckDB simplified)
4087    #[serde(default)]
4088    pub group: Option<Box<Expression>>,
4089    /// Whether this is an UNPIVOT (vs PIVOT)
4090    #[serde(default)]
4091    pub unpivot: bool,
4092    /// For DuckDB UNPIVOT: INTO NAME col VALUE col
4093    #[serde(default)]
4094    pub into: Option<Box<Expression>>,
4095    /// Optional alias
4096    #[serde(default)]
4097    pub alias: Option<Identifier>,
4098    /// Include/exclude nulls (for UNPIVOT)
4099    #[serde(default)]
4100    pub include_nulls: Option<bool>,
4101    /// Default on null value (Snowflake)
4102    #[serde(default)]
4103    pub default_on_null: Option<Box<Expression>>,
4104    /// WITH clause (CTEs)
4105    #[serde(default, skip_serializing_if = "Option::is_none")]
4106    pub with: Option<With>,
4107}
4108
4109/// UNPIVOT operation
4110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4111#[cfg_attr(feature = "bindings", derive(TS))]
4112pub struct Unpivot {
4113    pub this: Expression,
4114    pub value_column: Identifier,
4115    pub name_column: Identifier,
4116    pub columns: Vec<Expression>,
4117    pub alias: Option<Identifier>,
4118    /// Whether the value_column was parenthesized in the original SQL
4119    #[serde(default)]
4120    pub value_column_parenthesized: bool,
4121    /// INCLUDE NULLS (true), EXCLUDE NULLS (false), or not specified (None)
4122    #[serde(default)]
4123    pub include_nulls: Option<bool>,
4124    /// Additional value columns when parenthesized (e.g., (first_half_sales, second_half_sales))
4125    #[serde(default, skip_serializing_if = "Vec::is_empty")]
4126    pub extra_value_columns: Vec<Identifier>,
4127}
4128
4129/// PIVOT alias for aliasing pivot expressions
4130/// The alias can be an identifier or an expression (for Oracle/BigQuery string concatenation aliases)
4131#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4132#[cfg_attr(feature = "bindings", derive(TS))]
4133pub struct PivotAlias {
4134    pub this: Expression,
4135    pub alias: Expression,
4136}
4137
4138/// PREWHERE clause (ClickHouse) - early filtering before WHERE
4139#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4140#[cfg_attr(feature = "bindings", derive(TS))]
4141pub struct PreWhere {
4142    pub this: Expression,
4143}
4144
4145/// STREAM definition (Snowflake) - for change data capture
4146#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4147#[cfg_attr(feature = "bindings", derive(TS))]
4148pub struct Stream {
4149    pub this: Expression,
4150    #[serde(skip_serializing_if = "Option::is_none")]
4151    pub on: Option<Expression>,
4152    #[serde(skip_serializing_if = "Option::is_none")]
4153    pub show_initial_rows: Option<bool>,
4154}
4155
4156/// USING DATA clause for data import statements
4157#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4158#[cfg_attr(feature = "bindings", derive(TS))]
4159pub struct UsingData {
4160    pub this: Expression,
4161}
4162
4163/// XML Namespace declaration
4164#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4165#[cfg_attr(feature = "bindings", derive(TS))]
4166pub struct XmlNamespace {
4167    pub this: Expression,
4168    #[serde(skip_serializing_if = "Option::is_none")]
4169    pub alias: Option<Identifier>,
4170}
4171
4172/// ROW FORMAT clause for Hive/Spark
4173#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4174#[cfg_attr(feature = "bindings", derive(TS))]
4175pub struct RowFormat {
4176    pub delimited: bool,
4177    pub fields_terminated_by: Option<String>,
4178    pub collection_items_terminated_by: Option<String>,
4179    pub map_keys_terminated_by: Option<String>,
4180    pub lines_terminated_by: Option<String>,
4181    pub null_defined_as: Option<String>,
4182}
4183
4184/// Directory insert for INSERT OVERWRITE DIRECTORY (Hive/Spark)
4185#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4186#[cfg_attr(feature = "bindings", derive(TS))]
4187pub struct DirectoryInsert {
4188    pub local: bool,
4189    pub path: String,
4190    pub row_format: Option<RowFormat>,
4191    /// STORED AS clause (e.g., TEXTFILE, ORC, PARQUET)
4192    #[serde(default)]
4193    pub stored_as: Option<String>,
4194}
4195
4196/// INSERT statement
4197#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4198#[cfg_attr(feature = "bindings", derive(TS))]
4199pub struct Insert {
4200    pub table: TableRef,
4201    pub columns: Vec<Identifier>,
4202    pub values: Vec<Vec<Expression>>,
4203    pub query: Option<Expression>,
4204    /// INSERT OVERWRITE for Hive/Spark
4205    pub overwrite: bool,
4206    /// PARTITION clause for Hive/Spark
4207    pub partition: Vec<(Identifier, Option<Expression>)>,
4208    /// INSERT OVERWRITE DIRECTORY for Hive/Spark
4209    #[serde(default)]
4210    pub directory: Option<DirectoryInsert>,
4211    /// RETURNING clause (PostgreSQL, SQLite)
4212    #[serde(default)]
4213    pub returning: Vec<Expression>,
4214    /// OUTPUT clause (TSQL)
4215    #[serde(default)]
4216    pub output: Option<OutputClause>,
4217    /// ON CONFLICT clause (PostgreSQL, SQLite)
4218    #[serde(default)]
4219    pub on_conflict: Option<Box<Expression>>,
4220    /// Leading comments before the statement
4221    #[serde(default)]
4222    pub leading_comments: Vec<String>,
4223    /// IF EXISTS clause (Hive)
4224    #[serde(default)]
4225    pub if_exists: bool,
4226    /// WITH clause (CTEs)
4227    #[serde(default)]
4228    pub with: Option<With>,
4229    /// INSERT IGNORE (MySQL) - ignore duplicate key errors
4230    #[serde(default)]
4231    pub ignore: bool,
4232    /// Source alias for VALUES clause (MySQL): VALUES (1, 2) AS new_data
4233    #[serde(default)]
4234    pub source_alias: Option<Identifier>,
4235    /// Table alias (PostgreSQL): INSERT INTO table AS t(...)
4236    #[serde(default)]
4237    pub alias: Option<Identifier>,
4238    /// Whether the alias uses explicit AS keyword
4239    #[serde(default)]
4240    pub alias_explicit_as: bool,
4241    /// DEFAULT VALUES (PostgreSQL): INSERT INTO t DEFAULT VALUES
4242    #[serde(default)]
4243    pub default_values: bool,
4244    /// BY NAME modifier (DuckDB): INSERT INTO x BY NAME SELECT ...
4245    #[serde(default)]
4246    pub by_name: bool,
4247    /// SQLite conflict action: INSERT OR ABORT|FAIL|IGNORE|REPLACE|ROLLBACK INTO ...
4248    #[serde(default, skip_serializing_if = "Option::is_none")]
4249    pub conflict_action: Option<String>,
4250    /// MySQL/SQLite REPLACE INTO statement (treat like INSERT)
4251    #[serde(default)]
4252    pub is_replace: bool,
4253    /// Oracle-style hint: `INSERT <hint> INTO ...` (for example Oracle APPEND hints)
4254    #[serde(default, skip_serializing_if = "Option::is_none")]
4255    pub hint: Option<Hint>,
4256    /// REPLACE WHERE clause (Databricks): INSERT INTO a REPLACE WHERE cond VALUES ...
4257    #[serde(default)]
4258    pub replace_where: Option<Box<Expression>>,
4259    /// Source table (Hive/Spark): INSERT OVERWRITE TABLE target TABLE source
4260    #[serde(default)]
4261    pub source: Option<Box<Expression>>,
4262    /// ClickHouse: INSERT INTO FUNCTION func_name(...) - the function call
4263    #[serde(default, skip_serializing_if = "Option::is_none")]
4264    pub function_target: Option<Box<Expression>>,
4265    /// ClickHouse: PARTITION BY expr
4266    #[serde(default, skip_serializing_if = "Option::is_none")]
4267    pub partition_by: Option<Box<Expression>>,
4268    /// ClickHouse: SETTINGS key = val, ...
4269    #[serde(default, skip_serializing_if = "Vec::is_empty")]
4270    pub settings: Vec<Expression>,
4271}
4272
4273/// OUTPUT clause (TSQL) - used in INSERT, UPDATE, DELETE
4274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4275#[cfg_attr(feature = "bindings", derive(TS))]
4276pub struct OutputClause {
4277    /// Columns/expressions to output
4278    pub columns: Vec<Expression>,
4279    /// Optional INTO target table or table variable
4280    #[serde(default)]
4281    pub into_table: Option<Expression>,
4282}
4283
4284/// UPDATE statement
4285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4286#[cfg_attr(feature = "bindings", derive(TS))]
4287pub struct Update {
4288    pub table: TableRef,
4289    /// Additional tables for multi-table UPDATE (MySQL syntax)
4290    #[serde(default)]
4291    pub extra_tables: Vec<TableRef>,
4292    /// JOINs attached to the table list (MySQL multi-table syntax)
4293    #[serde(default)]
4294    pub table_joins: Vec<Join>,
4295    pub set: Vec<(Identifier, Expression)>,
4296    pub from_clause: Option<From>,
4297    /// JOINs after FROM clause (PostgreSQL, Snowflake, SQL Server syntax)
4298    #[serde(default)]
4299    pub from_joins: Vec<Join>,
4300    pub where_clause: Option<Where>,
4301    /// RETURNING clause (PostgreSQL, SQLite)
4302    #[serde(default)]
4303    pub returning: Vec<Expression>,
4304    /// OUTPUT clause (TSQL)
4305    #[serde(default)]
4306    pub output: Option<OutputClause>,
4307    /// WITH clause (CTEs)
4308    #[serde(default)]
4309    pub with: Option<With>,
4310    /// Leading comments before the statement
4311    #[serde(default)]
4312    pub leading_comments: Vec<String>,
4313    /// LIMIT clause (MySQL)
4314    #[serde(default)]
4315    pub limit: Option<Expression>,
4316    /// ORDER BY clause (MySQL)
4317    #[serde(default)]
4318    pub order_by: Option<OrderBy>,
4319    /// Whether FROM clause appears before SET (Snowflake syntax)
4320    #[serde(default)]
4321    pub from_before_set: bool,
4322}
4323
4324/// DELETE statement
4325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4326#[cfg_attr(feature = "bindings", derive(TS))]
4327pub struct Delete {
4328    pub table: TableRef,
4329    /// ClickHouse: ON CLUSTER clause for distributed DDL
4330    #[serde(default, skip_serializing_if = "Option::is_none")]
4331    pub on_cluster: Option<OnCluster>,
4332    /// Optional alias for the table
4333    pub alias: Option<Identifier>,
4334    /// Whether the alias was declared with explicit AS keyword
4335    #[serde(default)]
4336    pub alias_explicit_as: bool,
4337    /// PostgreSQL/DuckDB USING clause - additional tables to join
4338    pub using: Vec<TableRef>,
4339    pub where_clause: Option<Where>,
4340    /// OUTPUT clause (TSQL)
4341    #[serde(default)]
4342    pub output: Option<OutputClause>,
4343    /// Leading comments before the statement
4344    #[serde(default)]
4345    pub leading_comments: Vec<String>,
4346    /// WITH clause (CTEs)
4347    #[serde(default)]
4348    pub with: Option<With>,
4349    /// LIMIT clause (MySQL)
4350    #[serde(default)]
4351    pub limit: Option<Expression>,
4352    /// ORDER BY clause (MySQL)
4353    #[serde(default)]
4354    pub order_by: Option<OrderBy>,
4355    /// RETURNING clause (PostgreSQL)
4356    #[serde(default)]
4357    pub returning: Vec<Expression>,
4358    /// MySQL multi-table DELETE: DELETE t1, t2 FROM ... or DELETE FROM t1, t2 USING ...
4359    /// These are the target tables to delete from
4360    #[serde(default)]
4361    pub tables: Vec<TableRef>,
4362    /// True if tables were after FROM keyword (DELETE FROM t1, t2 USING syntax)
4363    /// False if tables were before FROM keyword (DELETE t1, t2 FROM syntax)
4364    #[serde(default)]
4365    pub tables_from_using: bool,
4366    /// JOINs in MySQL multi-table DELETE: DELETE t1 FROM t1 LEFT JOIN t2 ...
4367    #[serde(default)]
4368    pub joins: Vec<Join>,
4369    /// FORCE INDEX hint (MySQL): DELETE FROM t FORCE INDEX (idx)
4370    #[serde(default)]
4371    pub force_index: Option<String>,
4372    /// BigQuery-style DELETE without FROM keyword: DELETE table WHERE ...
4373    #[serde(default)]
4374    pub no_from: bool,
4375}
4376
4377/// COPY statement (Snowflake, PostgreSQL, DuckDB, TSQL)
4378#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4379#[cfg_attr(feature = "bindings", derive(TS))]
4380pub struct CopyStmt {
4381    /// Target table or query
4382    pub this: Expression,
4383    /// True for FROM (loading into table), false for TO (exporting)
4384    pub kind: bool,
4385    /// Source/destination file(s) or stage
4386    pub files: Vec<Expression>,
4387    /// Copy parameters
4388    #[serde(default)]
4389    pub params: Vec<CopyParameter>,
4390    /// Credentials for external access
4391    #[serde(default)]
4392    pub credentials: Option<Box<Credentials>>,
4393    /// Whether the INTO keyword was used (COPY INTO vs COPY)
4394    #[serde(default)]
4395    pub is_into: bool,
4396    /// Whether parameters are wrapped in WITH (...) syntax
4397    #[serde(default)]
4398    pub with_wrapped: bool,
4399}
4400
4401/// COPY parameter (e.g., FILE_FORMAT = CSV or FORMAT PARQUET)
4402#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4403#[cfg_attr(feature = "bindings", derive(TS))]
4404pub struct CopyParameter {
4405    pub name: String,
4406    pub value: Option<Expression>,
4407    pub values: Vec<Expression>,
4408    /// Whether the parameter used = sign (TSQL: KEY = VALUE vs DuckDB: KEY VALUE)
4409    #[serde(default)]
4410    pub eq: bool,
4411}
4412
4413/// Credentials for external access (S3, Azure, etc.)
4414#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4415#[cfg_attr(feature = "bindings", derive(TS))]
4416pub struct Credentials {
4417    pub credentials: Vec<(String, String)>,
4418    pub encryption: Option<String>,
4419    pub storage: Option<String>,
4420}
4421
4422/// PUT statement (Snowflake)
4423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4424#[cfg_attr(feature = "bindings", derive(TS))]
4425pub struct PutStmt {
4426    /// Source file path
4427    pub source: String,
4428    /// Whether source was quoted in the original SQL
4429    #[serde(default)]
4430    pub source_quoted: bool,
4431    /// Target stage
4432    pub target: Expression,
4433    /// PUT parameters
4434    #[serde(default)]
4435    pub params: Vec<CopyParameter>,
4436}
4437
4438/// Stage reference (Snowflake) - @stage_name or @namespace.stage/path
4439#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4440#[cfg_attr(feature = "bindings", derive(TS))]
4441pub struct StageReference {
4442    /// Stage name including @ prefix (e.g., "@mystage", "@namespace.mystage")
4443    pub name: String,
4444    /// Optional path within the stage (e.g., "/path/to/file.csv")
4445    #[serde(default)]
4446    pub path: Option<String>,
4447    /// Optional FILE_FORMAT parameter
4448    #[serde(default)]
4449    pub file_format: Option<Expression>,
4450    /// Optional PATTERN parameter
4451    #[serde(default)]
4452    pub pattern: Option<String>,
4453    /// Whether the stage reference was originally quoted (e.g., '@mystage')
4454    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
4455    pub quoted: bool,
4456}
4457
4458/// Historical data / Time travel (Snowflake) - BEFORE (STATEMENT => ...) or AT (TIMESTAMP => ...)
4459#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4460#[cfg_attr(feature = "bindings", derive(TS))]
4461pub struct HistoricalData {
4462    /// The time travel kind: "BEFORE", "AT", or "END" (as an Identifier expression)
4463    pub this: Box<Expression>,
4464    /// The time travel type: "STATEMENT", "TIMESTAMP", "OFFSET", "STREAM", or "VERSION"
4465    pub kind: String,
4466    /// The expression value (e.g., the statement ID or timestamp)
4467    pub expression: Box<Expression>,
4468}
4469
4470/// Represent an aliased expression (`expr AS name`).
4471///
4472/// Used for column aliases in select-lists, table aliases on subqueries,
4473/// and column alias lists on table-valued expressions (e.g. `AS t(c1, c2)`).
4474#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4475#[cfg_attr(feature = "bindings", derive(TS))]
4476pub struct Alias {
4477    /// The expression being aliased.
4478    pub this: Expression,
4479    /// The alias name (required for simple aliases, optional when only column aliases provided)
4480    pub alias: Identifier,
4481    /// Optional column aliases for table-valued functions: AS t(col1, col2) or AS (col1, col2)
4482    #[serde(default)]
4483    pub column_aliases: Vec<Identifier>,
4484    /// Comments that appeared between the expression and AS keyword
4485    #[serde(default)]
4486    pub pre_alias_comments: Vec<String>,
4487    /// Trailing comments that appeared after the alias
4488    #[serde(default)]
4489    pub trailing_comments: Vec<String>,
4490    /// Inferred data type from type annotation
4491    #[serde(default, skip_serializing_if = "Option::is_none")]
4492    pub inferred_type: Option<DataType>,
4493}
4494
4495impl Alias {
4496    /// Create a simple alias
4497    pub fn new(this: Expression, alias: Identifier) -> Self {
4498        Self {
4499            this,
4500            alias,
4501            column_aliases: Vec::new(),
4502            pre_alias_comments: Vec::new(),
4503            trailing_comments: Vec::new(),
4504            inferred_type: None,
4505        }
4506    }
4507
4508    /// Create an alias with column aliases only (no table alias name)
4509    pub fn with_columns(this: Expression, column_aliases: Vec<Identifier>) -> Self {
4510        Self {
4511            this,
4512            alias: Identifier::empty(),
4513            column_aliases,
4514            pre_alias_comments: Vec::new(),
4515            trailing_comments: Vec::new(),
4516            inferred_type: None,
4517        }
4518    }
4519}
4520
4521/// Represent a type cast expression.
4522///
4523/// Covers both the standard `CAST(expr AS type)` syntax and the PostgreSQL
4524/// shorthand `expr::type`. Also used as the payload for `TryCast` and
4525/// `SafeCast` variants. Supports optional FORMAT (BigQuery) and DEFAULT ON
4526/// CONVERSION ERROR (Oracle) clauses.
4527#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4528#[cfg_attr(feature = "bindings", derive(TS))]
4529pub struct Cast {
4530    /// The expression being cast.
4531    pub this: Expression,
4532    /// The target data type.
4533    pub to: DataType,
4534    #[serde(default)]
4535    pub trailing_comments: Vec<String>,
4536    /// Whether PostgreSQL `::` syntax was used (true) vs CAST() function (false)
4537    #[serde(default)]
4538    pub double_colon_syntax: bool,
4539    /// FORMAT clause for BigQuery: CAST(x AS STRING FORMAT 'format_string')
4540    #[serde(skip_serializing_if = "Option::is_none", default)]
4541    pub format: Option<Box<Expression>>,
4542    /// DEFAULT value ON CONVERSION ERROR (Oracle): CAST(x AS type DEFAULT val ON CONVERSION ERROR)
4543    #[serde(skip_serializing_if = "Option::is_none", default)]
4544    pub default: Option<Box<Expression>>,
4545    /// Inferred data type from type annotation
4546    #[serde(default, skip_serializing_if = "Option::is_none")]
4547    pub inferred_type: Option<DataType>,
4548}
4549
4550///// COLLATE expression: expr COLLATE 'collation_name' or expr COLLATE collation_name
4551#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4552#[cfg_attr(feature = "bindings", derive(TS))]
4553pub struct CollationExpr {
4554    pub this: Expression,
4555    pub collation: String,
4556    /// True if the collation was single-quoted in the original SQL (string literal)
4557    #[serde(default)]
4558    pub quoted: bool,
4559    /// True if the collation was double-quoted in the original SQL (identifier)
4560    #[serde(default)]
4561    pub double_quoted: bool,
4562}
4563
4564/// Represent a CASE expression (both simple and searched forms).
4565///
4566/// When `operand` is `Some`, this is a simple CASE (`CASE x WHEN 1 THEN ...`).
4567/// When `operand` is `None`, this is a searched CASE (`CASE WHEN x > 0 THEN ...`).
4568/// Each entry in `whens` is a `(condition, result)` pair.
4569#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4570#[cfg_attr(feature = "bindings", derive(TS))]
4571pub struct Case {
4572    /// The operand for simple CASE, or `None` for searched CASE.
4573    pub operand: Option<Expression>,
4574    /// Pairs of (WHEN condition, THEN result).
4575    pub whens: Vec<(Expression, Expression)>,
4576    /// Optional ELSE result.
4577    pub else_: Option<Expression>,
4578    /// Comments from the CASE keyword (emitted after END)
4579    #[serde(default)]
4580    #[serde(skip_serializing_if = "Vec::is_empty")]
4581    pub comments: Vec<String>,
4582    /// Inferred data type from type annotation
4583    #[serde(default, skip_serializing_if = "Option::is_none")]
4584    pub inferred_type: Option<DataType>,
4585}
4586
4587/// Represent a binary operation (two operands separated by an operator).
4588///
4589/// This is the shared payload struct for all binary operator variants in the
4590/// [`Expression`] enum: arithmetic (`Add`, `Sub`, `Mul`, `Div`, `Mod`),
4591/// comparison (`Eq`, `Neq`, `Lt`, `Gt`, etc.), logical (`And`, `Or`),
4592/// bitwise, and dialect-specific operators. Comment fields enable round-trip
4593/// preservation of inline comments around operators.
4594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4595#[cfg_attr(feature = "bindings", derive(TS))]
4596pub struct BinaryOp {
4597    pub left: Expression,
4598    pub right: Expression,
4599    /// Comments after the left operand (before the operator)
4600    #[serde(default)]
4601    pub left_comments: Vec<String>,
4602    /// Comments after the operator (before the right operand)
4603    #[serde(default)]
4604    pub operator_comments: Vec<String>,
4605    /// Comments after the right operand
4606    #[serde(default)]
4607    pub trailing_comments: Vec<String>,
4608    /// Inferred data type from type annotation
4609    #[serde(default, skip_serializing_if = "Option::is_none")]
4610    pub inferred_type: Option<DataType>,
4611}
4612
4613impl BinaryOp {
4614    pub fn new(left: Expression, right: Expression) -> Self {
4615        Self {
4616            left,
4617            right,
4618            left_comments: Vec::new(),
4619            operator_comments: Vec::new(),
4620            trailing_comments: Vec::new(),
4621            inferred_type: None,
4622        }
4623    }
4624}
4625
4626/// LIKE/ILIKE operation with optional ESCAPE clause and quantifier (ANY/ALL)
4627#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4628#[cfg_attr(feature = "bindings", derive(TS))]
4629pub struct LikeOp {
4630    pub left: Expression,
4631    pub right: Expression,
4632    /// ESCAPE character/expression
4633    #[serde(default)]
4634    pub escape: Option<Expression>,
4635    /// Quantifier: ANY, ALL, or SOME
4636    #[serde(default)]
4637    pub quantifier: Option<String>,
4638    /// Inferred data type from type annotation
4639    #[serde(default, skip_serializing_if = "Option::is_none")]
4640    pub inferred_type: Option<DataType>,
4641}
4642
4643impl LikeOp {
4644    pub fn new(left: Expression, right: Expression) -> Self {
4645        Self {
4646            left,
4647            right,
4648            escape: None,
4649            quantifier: None,
4650            inferred_type: None,
4651        }
4652    }
4653
4654    pub fn with_escape(left: Expression, right: Expression, escape: Expression) -> Self {
4655        Self {
4656            left,
4657            right,
4658            escape: Some(escape),
4659            quantifier: None,
4660            inferred_type: None,
4661        }
4662    }
4663}
4664
4665/// Represent a unary operation (single operand with a prefix operator).
4666///
4667/// Shared payload for `Not`, `Neg`, and `BitwiseNot` variants.
4668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4669#[cfg_attr(feature = "bindings", derive(TS))]
4670pub struct UnaryOp {
4671    /// The operand expression.
4672    pub this: Expression,
4673    /// Inferred data type from type annotation
4674    #[serde(default, skip_serializing_if = "Option::is_none")]
4675    pub inferred_type: Option<DataType>,
4676}
4677
4678impl UnaryOp {
4679    pub fn new(this: Expression) -> Self {
4680        Self {
4681            this,
4682            inferred_type: None,
4683        }
4684    }
4685}
4686
4687/// Represent an IN predicate (`x IN (1, 2, 3)` or `x IN (SELECT ...)`).
4688///
4689/// Either `expressions` (a value list) or `query` (a subquery) is populated,
4690/// but not both. When `not` is true, the predicate is `NOT IN`.
4691#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4692#[cfg_attr(feature = "bindings", derive(TS))]
4693pub struct In {
4694    /// The expression being tested.
4695    pub this: Expression,
4696    /// The value list (mutually exclusive with `query`).
4697    pub expressions: Vec<Expression>,
4698    /// A subquery (mutually exclusive with `expressions`).
4699    pub query: Option<Expression>,
4700    /// Whether this is NOT IN.
4701    pub not: bool,
4702    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
4703    pub global: bool,
4704    /// BigQuery: IN UNNEST(expr)
4705    #[serde(default, skip_serializing_if = "Option::is_none")]
4706    pub unnest: Option<Box<Expression>>,
4707    /// Whether the right side is a bare field reference (no parentheses).
4708    /// Matches Python sqlglot's `field` attribute on `In` expression.
4709    /// e.g., `a IN subquery1` vs `a IN (subquery1)`
4710    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
4711    pub is_field: bool,
4712}
4713
4714/// Represent a BETWEEN predicate (`x BETWEEN low AND high`).
4715#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4716#[cfg_attr(feature = "bindings", derive(TS))]
4717pub struct Between {
4718    /// The expression being tested.
4719    pub this: Expression,
4720    /// The lower bound.
4721    pub low: Expression,
4722    /// The upper bound.
4723    pub high: Expression,
4724    /// Whether this is NOT BETWEEN.
4725    pub not: bool,
4726    /// SYMMETRIC/ASYMMETRIC qualifier: None = regular, Some(true) = SYMMETRIC, Some(false) = ASYMMETRIC
4727    #[serde(default)]
4728    pub symmetric: Option<bool>,
4729}
4730
4731/// IS NULL predicate
4732#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4733#[cfg_attr(feature = "bindings", derive(TS))]
4734pub struct IsNull {
4735    pub this: Expression,
4736    pub not: bool,
4737    /// Whether this was the postfix form (ISNULL/NOTNULL) vs standard (IS NULL/IS NOT NULL)
4738    #[serde(default)]
4739    pub postfix_form: bool,
4740}
4741
4742/// IS TRUE / IS FALSE predicate
4743#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4744#[cfg_attr(feature = "bindings", derive(TS))]
4745pub struct IsTrueFalse {
4746    pub this: Expression,
4747    pub not: bool,
4748}
4749
4750/// IS JSON predicate (SQL standard)
4751/// Checks if a value is valid JSON
4752#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4753#[cfg_attr(feature = "bindings", derive(TS))]
4754pub struct IsJson {
4755    pub this: Expression,
4756    /// JSON type: VALUE, SCALAR, OBJECT, or ARRAY (None = just IS JSON)
4757    pub json_type: Option<String>,
4758    /// Key uniqueness constraint
4759    pub unique_keys: Option<JsonUniqueKeys>,
4760    /// Whether IS NOT JSON
4761    pub negated: bool,
4762}
4763
4764/// JSON unique keys constraint variants
4765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4766#[cfg_attr(feature = "bindings", derive(TS))]
4767pub enum JsonUniqueKeys {
4768    /// WITH UNIQUE KEYS
4769    With,
4770    /// WITHOUT UNIQUE KEYS
4771    Without,
4772    /// UNIQUE KEYS (shorthand for WITH UNIQUE KEYS)
4773    Shorthand,
4774}
4775
4776/// Represent an EXISTS predicate (`EXISTS (SELECT ...)` or `NOT EXISTS (...)`).
4777#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4778#[cfg_attr(feature = "bindings", derive(TS))]
4779pub struct Exists {
4780    /// The subquery expression.
4781    pub this: Expression,
4782    /// Whether this is NOT EXISTS.
4783    pub not: bool,
4784}
4785
4786/// Represent a scalar function call (e.g. `UPPER(name)`, `COALESCE(a, b)`).
4787///
4788/// This is the generic function node. Well-known aggregates, window functions,
4789/// and built-in functions each have their own dedicated `Expression` variants
4790/// (e.g. `Count`, `Sum`, `WindowFunction`). Functions that the parser does
4791/// not recognize as built-ins are represented with this struct.
4792#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4793#[cfg_attr(feature = "bindings", derive(TS))]
4794pub struct Function {
4795    /// The function name, as originally written (may be schema-qualified).
4796    pub name: String,
4797    /// Positional arguments to the function.
4798    pub args: Vec<Expression>,
4799    /// Whether DISTINCT was specified inside the call (e.g. `COUNT(DISTINCT x)`).
4800    pub distinct: bool,
4801    #[serde(default)]
4802    pub trailing_comments: Vec<String>,
4803    /// Whether this function uses bracket syntax (e.g., MAP[keys, values])
4804    #[serde(default)]
4805    pub use_bracket_syntax: bool,
4806    /// Whether this function was called without parentheses (e.g., CURRENT_TIMESTAMP vs CURRENT_TIMESTAMP())
4807    #[serde(default)]
4808    pub no_parens: bool,
4809    /// Whether the function name was quoted (e.g., `p.d.UdF` in BigQuery)
4810    #[serde(default)]
4811    pub quoted: bool,
4812    /// Source position span
4813    #[serde(default, skip_serializing_if = "Option::is_none")]
4814    pub span: Option<Span>,
4815    /// Inferred data type from type annotation
4816    #[serde(default, skip_serializing_if = "Option::is_none")]
4817    pub inferred_type: Option<DataType>,
4818}
4819
4820impl Default for Function {
4821    fn default() -> Self {
4822        Self {
4823            name: String::new(),
4824            args: Vec::new(),
4825            distinct: false,
4826            trailing_comments: Vec::new(),
4827            use_bracket_syntax: false,
4828            no_parens: false,
4829            quoted: false,
4830            span: None,
4831            inferred_type: None,
4832        }
4833    }
4834}
4835
4836impl Function {
4837    pub fn new(name: impl Into<String>, args: Vec<Expression>) -> Self {
4838        Self {
4839            name: name.into(),
4840            args,
4841            distinct: false,
4842            trailing_comments: Vec::new(),
4843            use_bracket_syntax: false,
4844            no_parens: false,
4845            quoted: false,
4846            span: None,
4847            inferred_type: None,
4848        }
4849    }
4850}
4851
4852/// Represent a named aggregate function call with optional FILTER, ORDER BY, and LIMIT.
4853///
4854/// This struct is used for aggregate function calls that are not covered by
4855/// one of the dedicated typed variants (e.g. `Count`, `Sum`). It supports
4856/// SQL:2003 FILTER (WHERE ...) clauses, ordered-set aggregates, and
4857/// IGNORE NULLS / RESPECT NULLS modifiers.
4858#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4859#[cfg_attr(feature = "bindings", derive(TS))]
4860pub struct AggregateFunction {
4861    /// The aggregate function name (e.g. "JSON_AGG", "XMLAGG").
4862    pub name: String,
4863    /// Positional arguments.
4864    pub args: Vec<Expression>,
4865    /// Whether DISTINCT was specified.
4866    pub distinct: bool,
4867    /// Optional FILTER (WHERE ...) clause applied to the aggregate.
4868    pub filter: Option<Expression>,
4869    /// ORDER BY inside aggregate (e.g., JSON_AGG(x ORDER BY y))
4870    #[serde(default, skip_serializing_if = "Vec::is_empty")]
4871    pub order_by: Vec<Ordered>,
4872    /// LIMIT inside aggregate (e.g., ARRAY_CONCAT_AGG(x LIMIT 2))
4873    #[serde(default, skip_serializing_if = "Option::is_none")]
4874    pub limit: Option<Box<Expression>>,
4875    /// IGNORE NULLS / RESPECT NULLS
4876    #[serde(default, skip_serializing_if = "Option::is_none")]
4877    pub ignore_nulls: Option<bool>,
4878    /// Inferred data type from type annotation
4879    #[serde(default, skip_serializing_if = "Option::is_none")]
4880    pub inferred_type: Option<DataType>,
4881}
4882
4883/// Represent a window function call with its OVER clause.
4884///
4885/// The inner `this` expression is typically a window-specific expression
4886/// (e.g. `RowNumber`, `Rank`, `Lead`) or an aggregate used as a window
4887/// function.  The `over` field carries the PARTITION BY, ORDER BY, and
4888/// frame specification.
4889#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4890#[cfg_attr(feature = "bindings", derive(TS))]
4891pub struct WindowFunction {
4892    /// The function expression (e.g. ROW_NUMBER(), SUM(amount)).
4893    pub this: Expression,
4894    /// The OVER clause defining the window partitioning, ordering, and frame.
4895    pub over: Over,
4896    /// Oracle KEEP clause: KEEP (DENSE_RANK FIRST|LAST ORDER BY ...)
4897    #[serde(default, skip_serializing_if = "Option::is_none")]
4898    pub keep: Option<Keep>,
4899    /// Inferred data type from type annotation
4900    #[serde(default, skip_serializing_if = "Option::is_none")]
4901    pub inferred_type: Option<DataType>,
4902}
4903
4904/// Oracle KEEP clause for aggregate functions
4905/// Syntax: aggregate_function KEEP (DENSE_RANK FIRST|LAST ORDER BY column [ASC|DESC])
4906#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4907#[cfg_attr(feature = "bindings", derive(TS))]
4908pub struct Keep {
4909    /// true = FIRST, false = LAST
4910    pub first: bool,
4911    /// ORDER BY clause inside KEEP
4912    pub order_by: Vec<Ordered>,
4913}
4914
4915/// WITHIN GROUP clause (for ordered-set aggregate functions)
4916#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4917#[cfg_attr(feature = "bindings", derive(TS))]
4918pub struct WithinGroup {
4919    /// The aggregate function (LISTAGG, PERCENTILE_CONT, etc.)
4920    pub this: Expression,
4921    /// The ORDER BY clause within the group
4922    pub order_by: Vec<Ordered>,
4923}
4924
4925/// Represent the FROM clause of a SELECT statement.
4926///
4927/// Contains one or more table sources (tables, subqueries, table-valued
4928/// functions, etc.). Multiple entries represent comma-separated implicit joins.
4929#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4930#[cfg_attr(feature = "bindings", derive(TS))]
4931pub struct From {
4932    /// The table source expressions.
4933    pub expressions: Vec<Expression>,
4934}
4935
4936/// Represent a JOIN clause between two table sources.
4937///
4938/// The join condition can be specified via `on` (ON predicate) or `using`
4939/// (USING column list), but not both. The `kind` field determines the join
4940/// type (INNER, LEFT, CROSS, etc.).
4941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4942#[cfg_attr(feature = "bindings", derive(TS))]
4943pub struct Join {
4944    /// The right-hand table expression being joined.
4945    pub this: Expression,
4946    /// The ON condition (mutually exclusive with `using`).
4947    pub on: Option<Expression>,
4948    /// The USING column list (mutually exclusive with `on`).
4949    pub using: Vec<Identifier>,
4950    /// The join type (INNER, LEFT, RIGHT, FULL, CROSS, etc.).
4951    pub kind: JoinKind,
4952    /// Whether INNER keyword was explicitly used (INNER JOIN vs JOIN)
4953    pub use_inner_keyword: bool,
4954    /// Whether OUTER keyword was explicitly used (LEFT OUTER JOIN vs LEFT JOIN)
4955    pub use_outer_keyword: bool,
4956    /// Whether the ON/USING condition was deferred (assigned right-to-left for chained JOINs)
4957    pub deferred_condition: bool,
4958    /// TSQL join hint: LOOP, HASH, MERGE (e.g., INNER LOOP JOIN)
4959    #[serde(default, skip_serializing_if = "Option::is_none")]
4960    pub join_hint: Option<String>,
4961    /// Snowflake ASOF JOIN match condition (MATCH_CONDITION clause)
4962    #[serde(default, skip_serializing_if = "Option::is_none")]
4963    pub match_condition: Option<Expression>,
4964    /// PIVOT/UNPIVOT operations that follow this join (Oracle/TSQL syntax)
4965    #[serde(default, skip_serializing_if = "Vec::is_empty")]
4966    pub pivots: Vec<Expression>,
4967    /// Comments collected between join-kind keywords (for example `INNER <comment> JOIN`)
4968    #[serde(default, skip_serializing_if = "Vec::is_empty")]
4969    pub comments: Vec<String>,
4970    /// Nesting group identifier for nested join pretty-printing.
4971    /// Joins in the same group were parsed together; group boundaries come from
4972    /// deferred condition resolution phases.
4973    #[serde(default)]
4974    pub nesting_group: usize,
4975    /// Snowflake: DIRECTED keyword in JOIN (e.g., CROSS DIRECTED JOIN)
4976    #[serde(default)]
4977    pub directed: bool,
4978}
4979
4980/// Enumerate all supported SQL join types.
4981///
4982/// Covers the standard join types (INNER, LEFT, RIGHT, FULL, CROSS, NATURAL)
4983/// as well as dialect-specific variants: SEMI/ANTI joins, LATERAL joins,
4984/// CROSS/OUTER APPLY (TSQL), ASOF joins (DuckDB/Snowflake), ARRAY joins
4985/// (ClickHouse), STRAIGHT_JOIN (MySQL), and implicit comma-joins.
4986#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
4987#[cfg_attr(feature = "bindings", derive(TS))]
4988pub enum JoinKind {
4989    Inner,
4990    Left,
4991    Right,
4992    Full,
4993    Outer, // Standalone OUTER JOIN (without LEFT/RIGHT/FULL)
4994    Cross,
4995    Natural,
4996    NaturalLeft,
4997    NaturalRight,
4998    NaturalFull,
4999    Semi,
5000    Anti,
5001    // Directional SEMI/ANTI joins
5002    LeftSemi,
5003    LeftAnti,
5004    RightSemi,
5005    RightAnti,
5006    // SQL Server specific
5007    CrossApply,
5008    OuterApply,
5009    // Time-series specific
5010    AsOf,
5011    AsOfLeft,
5012    AsOfRight,
5013    // Lateral join
5014    Lateral,
5015    LeftLateral,
5016    // MySQL specific
5017    Straight,
5018    // Implicit join (comma-separated tables: FROM a, b)
5019    Implicit,
5020    // ClickHouse ARRAY JOIN
5021    Array,
5022    LeftArray,
5023    // ClickHouse PASTE JOIN (positional join)
5024    Paste,
5025    // DuckDB POSITIONAL JOIN
5026    Positional,
5027}
5028
5029impl Default for JoinKind {
5030    fn default() -> Self {
5031        JoinKind::Inner
5032    }
5033}
5034
5035/// Parenthesized table expression with joins
5036/// Represents: (tbl1 CROSS JOIN tbl2) or ((SELECT 1) CROSS JOIN (SELECT 2))
5037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5038#[cfg_attr(feature = "bindings", derive(TS))]
5039pub struct JoinedTable {
5040    /// The left-hand side table expression
5041    pub left: Expression,
5042    /// The joins applied to the left table
5043    pub joins: Vec<Join>,
5044    /// LATERAL VIEW clauses (Hive/Spark)
5045    pub lateral_views: Vec<LateralView>,
5046    /// Optional alias for the joined table expression
5047    pub alias: Option<Identifier>,
5048}
5049
5050/// Represent a WHERE clause containing a boolean filter predicate.
5051#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5052#[cfg_attr(feature = "bindings", derive(TS))]
5053pub struct Where {
5054    /// The filter predicate expression.
5055    pub this: Expression,
5056}
5057
5058/// Represent a GROUP BY clause with optional ALL/DISTINCT and WITH TOTALS modifiers.
5059///
5060/// The `expressions` list may contain plain columns, ordinal positions,
5061/// ROLLUP/CUBE/GROUPING SETS expressions, or the special empty-set `()`.
5062#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5063#[cfg_attr(feature = "bindings", derive(TS))]
5064pub struct GroupBy {
5065    /// The grouping expressions.
5066    pub expressions: Vec<Expression>,
5067    /// GROUP BY modifier: Some(true) = ALL, Some(false) = DISTINCT, None = no modifier
5068    #[serde(default)]
5069    pub all: Option<bool>,
5070    /// ClickHouse: WITH TOTALS modifier
5071    #[serde(default)]
5072    pub totals: bool,
5073    /// Leading comments that appeared before the GROUP BY keyword
5074    #[serde(default, skip_serializing_if = "Vec::is_empty")]
5075    pub comments: Vec<String>,
5076}
5077
5078/// Represent a HAVING clause containing a predicate over aggregate results.
5079#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5080#[cfg_attr(feature = "bindings", derive(TS))]
5081pub struct Having {
5082    /// The filter predicate, typically involving aggregate functions.
5083    pub this: Expression,
5084    /// Leading comments that appeared before the HAVING keyword
5085    #[serde(default, skip_serializing_if = "Vec::is_empty")]
5086    pub comments: Vec<String>,
5087}
5088
5089/// Represent an ORDER BY clause containing one or more sort specifications.
5090#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5091#[cfg_attr(feature = "bindings", derive(TS))]
5092pub struct OrderBy {
5093    /// The sort specifications, each with direction and null ordering.
5094    pub expressions: Vec<Ordered>,
5095    /// Whether this is ORDER SIBLINGS BY (Oracle hierarchical queries)
5096    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
5097    pub siblings: bool,
5098    /// Leading comments that appeared before the ORDER BY keyword
5099    #[serde(default, skip_serializing_if = "Vec::is_empty")]
5100    pub comments: Vec<String>,
5101}
5102
5103/// Represent an expression with sort direction and null ordering.
5104///
5105/// Used inside ORDER BY clauses, window frame ORDER BY, and index definitions.
5106/// When `desc` is false the sort is ascending. The `nulls_first` field
5107/// controls the NULLS FIRST / NULLS LAST modifier; `None` means unspecified
5108/// (database default).
5109#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5110#[cfg_attr(feature = "bindings", derive(TS))]
5111pub struct Ordered {
5112    /// The expression to sort by.
5113    pub this: Expression,
5114    /// Whether the sort direction is descending (true) or ascending (false).
5115    pub desc: bool,
5116    /// `Some(true)` = NULLS FIRST, `Some(false)` = NULLS LAST, `None` = unspecified.
5117    pub nulls_first: Option<bool>,
5118    /// Whether ASC was explicitly written (not just implied)
5119    #[serde(default)]
5120    pub explicit_asc: bool,
5121    /// ClickHouse WITH FILL clause
5122    #[serde(default, skip_serializing_if = "Option::is_none")]
5123    pub with_fill: Option<Box<WithFill>>,
5124}
5125
5126impl Ordered {
5127    pub fn asc(expr: Expression) -> Self {
5128        Self {
5129            this: expr,
5130            desc: false,
5131            nulls_first: None,
5132            explicit_asc: false,
5133            with_fill: None,
5134        }
5135    }
5136
5137    pub fn desc(expr: Expression) -> Self {
5138        Self {
5139            this: expr,
5140            desc: true,
5141            nulls_first: None,
5142            explicit_asc: false,
5143            with_fill: None,
5144        }
5145    }
5146}
5147
5148/// DISTRIBUTE BY clause (Hive/Spark)
5149/// Controls how rows are distributed across reducers
5150#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5151#[cfg_attr(feature = "bindings", derive(TS))]
5152#[cfg_attr(feature = "bindings", ts(export))]
5153pub struct DistributeBy {
5154    pub expressions: Vec<Expression>,
5155}
5156
5157/// CLUSTER BY clause (Hive/Spark)
5158/// Combines DISTRIBUTE BY and SORT BY on the same columns
5159#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5160#[cfg_attr(feature = "bindings", derive(TS))]
5161#[cfg_attr(feature = "bindings", ts(export))]
5162pub struct ClusterBy {
5163    pub expressions: Vec<Ordered>,
5164}
5165
5166/// SORT BY clause (Hive/Spark)
5167/// Sorts data within each reducer (local sort, not global)
5168#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5169#[cfg_attr(feature = "bindings", derive(TS))]
5170#[cfg_attr(feature = "bindings", ts(export))]
5171pub struct SortBy {
5172    pub expressions: Vec<Ordered>,
5173}
5174
5175/// LATERAL VIEW clause (Hive/Spark)
5176/// Used for unnesting arrays/maps with EXPLODE, POSEXPLODE, etc.
5177#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5178#[cfg_attr(feature = "bindings", derive(TS))]
5179#[cfg_attr(feature = "bindings", ts(export))]
5180pub struct LateralView {
5181    /// The table-generating function (EXPLODE, POSEXPLODE, etc.)
5182    pub this: Expression,
5183    /// Table alias for the generated table
5184    pub table_alias: Option<Identifier>,
5185    /// Column aliases for the generated columns
5186    pub column_aliases: Vec<Identifier>,
5187    /// OUTER keyword - preserve nulls when input is empty/null
5188    pub outer: bool,
5189}
5190
5191/// Query hint
5192#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5193#[cfg_attr(feature = "bindings", derive(TS))]
5194#[cfg_attr(feature = "bindings", ts(export))]
5195pub struct Hint {
5196    pub expressions: Vec<HintExpression>,
5197}
5198
5199/// Individual hint expression
5200#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5201#[cfg_attr(feature = "bindings", derive(TS))]
5202#[cfg_attr(feature = "bindings", ts(export))]
5203pub enum HintExpression {
5204    /// Function-style hint: USE_HASH(table)
5205    Function { name: String, args: Vec<Expression> },
5206    /// Simple identifier hint: PARALLEL
5207    Identifier(String),
5208    /// Raw hint text (unparsed)
5209    Raw(String),
5210}
5211
5212/// Pseudocolumn type
5213#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
5214#[cfg_attr(feature = "bindings", derive(TS))]
5215#[cfg_attr(feature = "bindings", ts(export))]
5216pub enum PseudocolumnType {
5217    Rownum,      // Oracle ROWNUM
5218    Rowid,       // Oracle ROWID
5219    Level,       // Oracle LEVEL (for CONNECT BY)
5220    Sysdate,     // Oracle SYSDATE
5221    ObjectId,    // Oracle OBJECT_ID
5222    ObjectValue, // Oracle OBJECT_VALUE
5223}
5224
5225impl PseudocolumnType {
5226    pub fn as_str(&self) -> &'static str {
5227        match self {
5228            PseudocolumnType::Rownum => "ROWNUM",
5229            PseudocolumnType::Rowid => "ROWID",
5230            PseudocolumnType::Level => "LEVEL",
5231            PseudocolumnType::Sysdate => "SYSDATE",
5232            PseudocolumnType::ObjectId => "OBJECT_ID",
5233            PseudocolumnType::ObjectValue => "OBJECT_VALUE",
5234        }
5235    }
5236
5237    pub fn from_str(s: &str) -> Option<Self> {
5238        match s.to_uppercase().as_str() {
5239            "ROWNUM" => Some(PseudocolumnType::Rownum),
5240            "ROWID" => Some(PseudocolumnType::Rowid),
5241            "LEVEL" => Some(PseudocolumnType::Level),
5242            "SYSDATE" => Some(PseudocolumnType::Sysdate),
5243            "OBJECT_ID" => Some(PseudocolumnType::ObjectId),
5244            "OBJECT_VALUE" => Some(PseudocolumnType::ObjectValue),
5245            _ => None,
5246        }
5247    }
5248}
5249
5250/// Pseudocolumn expression (Oracle ROWNUM, ROWID, LEVEL, etc.)
5251/// These are special identifiers that should not be quoted
5252#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5253#[cfg_attr(feature = "bindings", derive(TS))]
5254#[cfg_attr(feature = "bindings", ts(export))]
5255pub struct Pseudocolumn {
5256    pub kind: PseudocolumnType,
5257}
5258
5259impl Pseudocolumn {
5260    pub fn rownum() -> Self {
5261        Self {
5262            kind: PseudocolumnType::Rownum,
5263        }
5264    }
5265
5266    pub fn rowid() -> Self {
5267        Self {
5268            kind: PseudocolumnType::Rowid,
5269        }
5270    }
5271
5272    pub fn level() -> Self {
5273        Self {
5274            kind: PseudocolumnType::Level,
5275        }
5276    }
5277}
5278
5279/// Oracle CONNECT BY clause for hierarchical queries
5280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5281#[cfg_attr(feature = "bindings", derive(TS))]
5282#[cfg_attr(feature = "bindings", ts(export))]
5283pub struct Connect {
5284    /// START WITH condition (optional, can come before or after CONNECT BY)
5285    pub start: Option<Expression>,
5286    /// CONNECT BY condition (required, contains PRIOR references)
5287    pub connect: Expression,
5288    /// NOCYCLE keyword to prevent infinite loops
5289    pub nocycle: bool,
5290}
5291
5292/// Oracle PRIOR expression - references parent row's value in CONNECT BY
5293#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5294#[cfg_attr(feature = "bindings", derive(TS))]
5295#[cfg_attr(feature = "bindings", ts(export))]
5296pub struct Prior {
5297    pub this: Expression,
5298}
5299
5300/// Oracle CONNECT_BY_ROOT function - returns root row's column value
5301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5302#[cfg_attr(feature = "bindings", derive(TS))]
5303#[cfg_attr(feature = "bindings", ts(export))]
5304pub struct ConnectByRoot {
5305    pub this: Expression,
5306}
5307
5308/// MATCH_RECOGNIZE clause for row pattern matching (Oracle/Snowflake/Presto/Trino)
5309#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5310#[cfg_attr(feature = "bindings", derive(TS))]
5311#[cfg_attr(feature = "bindings", ts(export))]
5312pub struct MatchRecognize {
5313    /// Source table/expression
5314    pub this: Option<Box<Expression>>,
5315    /// PARTITION BY expressions
5316    pub partition_by: Option<Vec<Expression>>,
5317    /// ORDER BY expressions
5318    pub order_by: Option<Vec<Ordered>>,
5319    /// MEASURES definitions
5320    pub measures: Option<Vec<MatchRecognizeMeasure>>,
5321    /// Row semantics (ONE ROW PER MATCH, ALL ROWS PER MATCH, etc.)
5322    pub rows: Option<MatchRecognizeRows>,
5323    /// AFTER MATCH SKIP behavior
5324    pub after: Option<MatchRecognizeAfter>,
5325    /// PATTERN definition (stored as raw string for complex regex patterns)
5326    pub pattern: Option<String>,
5327    /// DEFINE clauses (pattern variable definitions)
5328    pub define: Option<Vec<(Identifier, Expression)>>,
5329    /// Optional alias for the result
5330    pub alias: Option<Identifier>,
5331    /// Whether AS keyword was explicitly present before alias
5332    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
5333    pub alias_explicit_as: bool,
5334}
5335
5336/// MEASURES expression with optional RUNNING/FINAL semantics
5337#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5338#[cfg_attr(feature = "bindings", derive(TS))]
5339#[cfg_attr(feature = "bindings", ts(export))]
5340pub struct MatchRecognizeMeasure {
5341    /// The measure expression
5342    pub this: Expression,
5343    /// RUNNING or FINAL semantics (Snowflake-specific)
5344    pub window_frame: Option<MatchRecognizeSemantics>,
5345}
5346
5347/// Semantics for MEASURES in MATCH_RECOGNIZE
5348#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
5349#[cfg_attr(feature = "bindings", derive(TS))]
5350#[cfg_attr(feature = "bindings", ts(export))]
5351pub enum MatchRecognizeSemantics {
5352    Running,
5353    Final,
5354}
5355
5356/// Row output semantics for MATCH_RECOGNIZE
5357#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5358#[cfg_attr(feature = "bindings", derive(TS))]
5359#[cfg_attr(feature = "bindings", ts(export))]
5360pub enum MatchRecognizeRows {
5361    OneRowPerMatch,
5362    AllRowsPerMatch,
5363    AllRowsPerMatchShowEmptyMatches,
5364    AllRowsPerMatchOmitEmptyMatches,
5365    AllRowsPerMatchWithUnmatchedRows,
5366}
5367
5368/// AFTER MATCH SKIP behavior
5369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5370#[cfg_attr(feature = "bindings", derive(TS))]
5371#[cfg_attr(feature = "bindings", ts(export))]
5372pub enum MatchRecognizeAfter {
5373    PastLastRow,
5374    ToNextRow,
5375    ToFirst(Identifier),
5376    ToLast(Identifier),
5377}
5378
5379/// Represent a LIMIT clause that restricts the number of returned rows.
5380#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5381#[cfg_attr(feature = "bindings", derive(TS))]
5382pub struct Limit {
5383    /// The limit count expression.
5384    pub this: Expression,
5385    /// Whether PERCENT modifier is present (DuckDB: LIMIT 10 PERCENT)
5386    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
5387    pub percent: bool,
5388    /// Comments from before the LIMIT keyword (emitted after the limit value)
5389    #[serde(default)]
5390    #[serde(skip_serializing_if = "Vec::is_empty")]
5391    pub comments: Vec<String>,
5392}
5393
5394/// OFFSET clause
5395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5396#[cfg_attr(feature = "bindings", derive(TS))]
5397pub struct Offset {
5398    pub this: Expression,
5399    /// Whether ROW/ROWS keyword was used (SQL standard syntax)
5400    #[serde(skip_serializing_if = "Option::is_none", default)]
5401    pub rows: Option<bool>,
5402}
5403
5404/// TOP clause (SQL Server)
5405#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5406#[cfg_attr(feature = "bindings", derive(TS))]
5407pub struct Top {
5408    pub this: Expression,
5409    pub percent: bool,
5410    pub with_ties: bool,
5411    /// Whether the expression was parenthesized: TOP (10) vs TOP 10
5412    #[serde(default)]
5413    pub parenthesized: bool,
5414}
5415
5416/// FETCH FIRST/NEXT clause (SQL standard)
5417#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5418#[cfg_attr(feature = "bindings", derive(TS))]
5419pub struct Fetch {
5420    /// FIRST or NEXT
5421    pub direction: String,
5422    /// Count expression (optional)
5423    pub count: Option<Expression>,
5424    /// PERCENT modifier
5425    pub percent: bool,
5426    /// ROWS or ROW keyword present
5427    pub rows: bool,
5428    /// WITH TIES modifier
5429    pub with_ties: bool,
5430}
5431
5432/// Represent a QUALIFY clause for filtering on window function results.
5433///
5434/// Supported by Snowflake, BigQuery, DuckDB, and Databricks. The predicate
5435/// typically references a window function (e.g.
5436/// `QUALIFY ROW_NUMBER() OVER (PARTITION BY id ORDER BY ts DESC) = 1`).
5437#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5438#[cfg_attr(feature = "bindings", derive(TS))]
5439pub struct Qualify {
5440    /// The filter predicate over window function results.
5441    pub this: Expression,
5442}
5443
5444/// SAMPLE / TABLESAMPLE clause
5445#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5446#[cfg_attr(feature = "bindings", derive(TS))]
5447pub struct Sample {
5448    pub method: SampleMethod,
5449    pub size: Expression,
5450    pub seed: Option<Expression>,
5451    /// ClickHouse OFFSET expression after SAMPLE size
5452    #[serde(default)]
5453    pub offset: Option<Expression>,
5454    /// Whether the unit comes after the size (e.g., "100 ROWS" vs "ROW 100")
5455    pub unit_after_size: bool,
5456    /// Whether the keyword was SAMPLE (true) or TABLESAMPLE (false)
5457    #[serde(default)]
5458    pub use_sample_keyword: bool,
5459    /// Whether the method was explicitly specified (BERNOULLI, SYSTEM, etc.)
5460    #[serde(default)]
5461    pub explicit_method: bool,
5462    /// Whether the method keyword appeared before the size (TABLESAMPLE BERNOULLI (10))
5463    #[serde(default)]
5464    pub method_before_size: bool,
5465    /// Whether SEED keyword was used (true) or REPEATABLE (false)
5466    #[serde(default)]
5467    pub use_seed_keyword: bool,
5468    /// BUCKET numerator for Hive bucket sampling (BUCKET 1 OUT OF 5)
5469    pub bucket_numerator: Option<Box<Expression>>,
5470    /// BUCKET denominator (the 5 in BUCKET 1 OUT OF 5)
5471    pub bucket_denominator: Option<Box<Expression>>,
5472    /// BUCKET field for ON clause (BUCKET 1 OUT OF 5 ON x)
5473    pub bucket_field: Option<Box<Expression>>,
5474    /// Whether this is a DuckDB USING SAMPLE clause (vs SAMPLE/TABLESAMPLE)
5475    #[serde(default)]
5476    pub is_using_sample: bool,
5477    /// Whether the unit was explicitly PERCENT (vs ROWS)
5478    #[serde(default)]
5479    pub is_percent: bool,
5480    /// Whether to suppress method output (for cross-dialect transpilation)
5481    #[serde(default)]
5482    pub suppress_method_output: bool,
5483}
5484
5485/// Sample method
5486#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
5487#[cfg_attr(feature = "bindings", derive(TS))]
5488pub enum SampleMethod {
5489    Bernoulli,
5490    System,
5491    Block,
5492    Row,
5493    Percent,
5494    /// Hive bucket sampling
5495    Bucket,
5496    /// DuckDB reservoir sampling
5497    Reservoir,
5498}
5499
5500/// Named window definition (WINDOW w AS (...))
5501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5502#[cfg_attr(feature = "bindings", derive(TS))]
5503pub struct NamedWindow {
5504    pub name: Identifier,
5505    pub spec: Over,
5506}
5507
5508/// Represent a WITH clause containing one or more Common Table Expressions (CTEs).
5509///
5510/// When `recursive` is true, the clause is `WITH RECURSIVE`, enabling CTEs
5511/// that reference themselves. Each CTE is defined in the `ctes` vector and
5512/// can be referenced by name in subsequent CTEs and in the main query body.
5513#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5514#[cfg_attr(feature = "bindings", derive(TS))]
5515pub struct With {
5516    /// The list of CTE definitions, in order.
5517    pub ctes: Vec<Cte>,
5518    /// Whether the WITH RECURSIVE keyword was used.
5519    pub recursive: bool,
5520    /// Leading comments before the statement
5521    #[serde(default)]
5522    pub leading_comments: Vec<String>,
5523    /// SEARCH/CYCLE clause for recursive CTEs (PostgreSQL)
5524    #[serde(default, skip_serializing_if = "Option::is_none")]
5525    pub search: Option<Box<Expression>>,
5526}
5527
5528/// Represent a single Common Table Expression definition.
5529///
5530/// A CTE has a name (`alias`), an optional column list, and a body query.
5531/// The `materialized` field maps to PostgreSQL's `MATERIALIZED` /
5532/// `NOT MATERIALIZED` hints. ClickHouse supports an inverted syntax where
5533/// the expression comes before the alias (`alias_first`).
5534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5535#[cfg_attr(feature = "bindings", derive(TS))]
5536pub struct Cte {
5537    /// The CTE name.
5538    pub alias: Identifier,
5539    /// The CTE body (typically a SELECT, UNION, etc.).
5540    pub this: Expression,
5541    /// Optional column alias list: `cte_name(c1, c2) AS (...)`.
5542    pub columns: Vec<Identifier>,
5543    /// `Some(true)` = MATERIALIZED, `Some(false)` = NOT MATERIALIZED, `None` = unspecified.
5544    pub materialized: Option<bool>,
5545    /// USING KEY (columns) for DuckDB recursive CTEs
5546    #[serde(default, skip_serializing_if = "Vec::is_empty")]
5547    pub key_expressions: Vec<Identifier>,
5548    /// ClickHouse supports expression-first WITH items: WITH <expr> AS <alias>
5549    #[serde(default)]
5550    pub alias_first: bool,
5551    /// Comments associated with this CTE (placed after alias name, before AS)
5552    #[serde(default, skip_serializing_if = "Vec::is_empty")]
5553    pub comments: Vec<String>,
5554}
5555
5556/// Window specification
5557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5558#[cfg_attr(feature = "bindings", derive(TS))]
5559pub struct WindowSpec {
5560    pub partition_by: Vec<Expression>,
5561    pub order_by: Vec<Ordered>,
5562    pub frame: Option<WindowFrame>,
5563}
5564
5565/// OVER clause
5566#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5567#[cfg_attr(feature = "bindings", derive(TS))]
5568pub struct Over {
5569    /// Named window reference (e.g., OVER w or OVER (w ORDER BY x))
5570    pub window_name: Option<Identifier>,
5571    pub partition_by: Vec<Expression>,
5572    pub order_by: Vec<Ordered>,
5573    pub frame: Option<WindowFrame>,
5574    pub alias: Option<Identifier>,
5575}
5576
5577/// Window frame
5578#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5579#[cfg_attr(feature = "bindings", derive(TS))]
5580pub struct WindowFrame {
5581    pub kind: WindowFrameKind,
5582    pub start: WindowFrameBound,
5583    pub end: Option<WindowFrameBound>,
5584    pub exclude: Option<WindowFrameExclude>,
5585    /// Original text of the frame kind keyword (preserves input case, e.g. "range")
5586    #[serde(default, skip_serializing_if = "Option::is_none")]
5587    pub kind_text: Option<String>,
5588    /// Original text of the start bound side keyword (e.g. "preceding")
5589    #[serde(default, skip_serializing_if = "Option::is_none")]
5590    pub start_side_text: Option<String>,
5591    /// Original text of the end bound side keyword
5592    #[serde(default, skip_serializing_if = "Option::is_none")]
5593    pub end_side_text: Option<String>,
5594}
5595
5596#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
5597#[cfg_attr(feature = "bindings", derive(TS))]
5598pub enum WindowFrameKind {
5599    Rows,
5600    Range,
5601    Groups,
5602}
5603
5604/// EXCLUDE clause for window frames
5605#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
5606#[cfg_attr(feature = "bindings", derive(TS))]
5607pub enum WindowFrameExclude {
5608    CurrentRow,
5609    Group,
5610    Ties,
5611    NoOthers,
5612}
5613
5614#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5615#[cfg_attr(feature = "bindings", derive(TS))]
5616pub enum WindowFrameBound {
5617    CurrentRow,
5618    UnboundedPreceding,
5619    UnboundedFollowing,
5620    Preceding(Box<Expression>),
5621    Following(Box<Expression>),
5622    /// Bare PRECEDING without value (inverted syntax: just "PRECEDING")
5623    BarePreceding,
5624    /// Bare FOLLOWING without value (inverted syntax: just "FOLLOWING")
5625    BareFollowing,
5626    /// Bare numeric bound without PRECEDING/FOLLOWING (e.g., RANGE BETWEEN 1 AND 3)
5627    Value(Box<Expression>),
5628}
5629
5630/// Struct field with optional OPTIONS clause (BigQuery) and COMMENT (Spark/Databricks)
5631#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5632#[cfg_attr(feature = "bindings", derive(TS))]
5633pub struct StructField {
5634    pub name: String,
5635    pub data_type: DataType,
5636    #[serde(default, skip_serializing_if = "Vec::is_empty")]
5637    pub options: Vec<Expression>,
5638    #[serde(default, skip_serializing_if = "Option::is_none")]
5639    pub comment: Option<String>,
5640}
5641
5642impl StructField {
5643    /// Create a new struct field without options
5644    pub fn new(name: String, data_type: DataType) -> Self {
5645        Self {
5646            name,
5647            data_type,
5648            options: Vec::new(),
5649            comment: None,
5650        }
5651    }
5652
5653    /// Create a new struct field with options
5654    pub fn with_options(name: String, data_type: DataType, options: Vec<Expression>) -> Self {
5655        Self {
5656            name,
5657            data_type,
5658            options,
5659            comment: None,
5660        }
5661    }
5662
5663    /// Create a new struct field with options and comment
5664    pub fn with_options_and_comment(
5665        name: String,
5666        data_type: DataType,
5667        options: Vec<Expression>,
5668        comment: Option<String>,
5669    ) -> Self {
5670        Self {
5671            name,
5672            data_type,
5673            options,
5674            comment,
5675        }
5676    }
5677}
5678
5679/// Enumerate all SQL data types recognized by the parser.
5680///
5681/// Covers standard SQL types (BOOLEAN, INT, VARCHAR, TIMESTAMP, etc.) as well
5682/// as dialect-specific types (JSONB, VECTOR, OBJECT, etc.). Parametric types
5683/// like ARRAY, MAP, and STRUCT are represented with nested [`DataType`] fields.
5684///
5685/// This enum is used in CAST expressions, column definitions, function return
5686/// types, and anywhere a data type specification appears in SQL.
5687///
5688/// Types that do not match any known variant fall through to `Custom { name }`,
5689/// preserving the original type name for round-trip fidelity.
5690#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5691#[cfg_attr(feature = "bindings", derive(TS))]
5692#[serde(tag = "data_type", rename_all = "snake_case")]
5693pub enum DataType {
5694    // Numeric
5695    Boolean,
5696    TinyInt {
5697        length: Option<u32>,
5698    },
5699    SmallInt {
5700        length: Option<u32>,
5701    },
5702    /// Int type with optional length. `integer_spelling` indicates whether the original
5703    /// type was spelled as `INTEGER` (true) vs `INT` (false), used for certain dialects
5704    /// like Databricks that preserve the original spelling in specific contexts (e.g., ?:: syntax).
5705    Int {
5706        length: Option<u32>,
5707        #[serde(default, skip_serializing_if = "std::ops::Not::not")]
5708        integer_spelling: bool,
5709    },
5710    BigInt {
5711        length: Option<u32>,
5712    },
5713    /// Float type with optional precision and scale. `real_spelling` indicates whether the original
5714    /// type was spelled as `REAL` (true) vs `FLOAT` (false), used for dialects like Redshift that
5715    /// preserve the original spelling.
5716    Float {
5717        precision: Option<u32>,
5718        scale: Option<u32>,
5719        #[serde(default, skip_serializing_if = "std::ops::Not::not")]
5720        real_spelling: bool,
5721    },
5722    Double {
5723        precision: Option<u32>,
5724        scale: Option<u32>,
5725    },
5726    Decimal {
5727        precision: Option<u32>,
5728        scale: Option<u32>,
5729    },
5730
5731    // String
5732    Char {
5733        length: Option<u32>,
5734    },
5735    /// VarChar type with optional length. `parenthesized_length` indicates whether the length
5736    /// was wrapped in extra parentheses (Hive: `VARCHAR((50))` inside STRUCT definitions).
5737    VarChar {
5738        length: Option<u32>,
5739        #[serde(default, skip_serializing_if = "std::ops::Not::not")]
5740        parenthesized_length: bool,
5741    },
5742    /// String type with optional max length (BigQuery STRING(n))
5743    String {
5744        length: Option<u32>,
5745    },
5746    Text,
5747    /// TEXT with optional length: TEXT(n) - used by MySQL, SQLite, DuckDB, etc.
5748    TextWithLength {
5749        length: u32,
5750    },
5751
5752    // Binary
5753    Binary {
5754        length: Option<u32>,
5755    },
5756    VarBinary {
5757        length: Option<u32>,
5758    },
5759    Blob,
5760
5761    // Bit
5762    Bit {
5763        length: Option<u32>,
5764    },
5765    VarBit {
5766        length: Option<u32>,
5767    },
5768
5769    // Date/Time
5770    Date,
5771    Time {
5772        precision: Option<u32>,
5773        #[serde(default)]
5774        timezone: bool,
5775    },
5776    Timestamp {
5777        precision: Option<u32>,
5778        timezone: bool,
5779    },
5780    Interval {
5781        unit: Option<String>,
5782        /// For range intervals like INTERVAL DAY TO HOUR
5783        #[serde(default, skip_serializing_if = "Option::is_none")]
5784        to: Option<String>,
5785    },
5786
5787    // JSON
5788    Json,
5789    JsonB,
5790
5791    // UUID
5792    Uuid,
5793
5794    // Array
5795    Array {
5796        element_type: Box<DataType>,
5797        /// Optional dimension size for PostgreSQL (e.g., [3] in INT[3])
5798        #[serde(default, skip_serializing_if = "Option::is_none")]
5799        dimension: Option<u32>,
5800    },
5801
5802    /// List type (Materialize): INT LIST, TEXT LIST LIST
5803    /// Uses postfix LIST syntax instead of ARRAY<T>
5804    List {
5805        element_type: Box<DataType>,
5806    },
5807
5808    // Struct/Map
5809    // nested: true means parenthesized syntax STRUCT(name TYPE, ...) (DuckDB/Presto/ROW)
5810    // nested: false means angle-bracket syntax STRUCT<name TYPE, ...> (BigQuery)
5811    Struct {
5812        fields: Vec<StructField>,
5813        nested: bool,
5814    },
5815    Map {
5816        key_type: Box<DataType>,
5817        value_type: Box<DataType>,
5818    },
5819
5820    // Enum type (DuckDB): ENUM('RED', 'GREEN', 'BLUE')
5821    Enum {
5822        values: Vec<String>,
5823        #[serde(default, skip_serializing_if = "Vec::is_empty")]
5824        assignments: Vec<Option<String>>,
5825    },
5826
5827    // Set type (MySQL): SET('a', 'b', 'c')
5828    Set {
5829        values: Vec<String>,
5830    },
5831
5832    // Union type (DuckDB): UNION(num INT, str TEXT)
5833    Union {
5834        fields: Vec<(String, DataType)>,
5835    },
5836
5837    // Vector (Snowflake / SingleStore)
5838    Vector {
5839        #[serde(default)]
5840        element_type: Option<Box<DataType>>,
5841        dimension: Option<u32>,
5842    },
5843
5844    // Object (Snowflake structured type)
5845    // fields: Vec of (field_name, field_type, not_null)
5846    Object {
5847        fields: Vec<(String, DataType, bool)>,
5848        modifier: Option<String>,
5849    },
5850
5851    // Nullable wrapper (ClickHouse): Nullable(String), Nullable(Int32)
5852    Nullable {
5853        inner: Box<DataType>,
5854    },
5855
5856    // Custom/User-defined
5857    Custom {
5858        name: String,
5859    },
5860
5861    // Spatial types
5862    Geometry {
5863        subtype: Option<String>,
5864        srid: Option<u32>,
5865    },
5866    Geography {
5867        subtype: Option<String>,
5868        srid: Option<u32>,
5869    },
5870
5871    // Character Set (for CONVERT USING in MySQL)
5872    // Renders as CHAR CHARACTER SET {name} in cast target
5873    CharacterSet {
5874        name: String,
5875    },
5876
5877    // Unknown
5878    Unknown,
5879}
5880
5881/// Array expression
5882#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5883#[cfg_attr(feature = "bindings", derive(TS))]
5884#[cfg_attr(feature = "bindings", ts(rename = "SqlArray"))]
5885pub struct Array {
5886    pub expressions: Vec<Expression>,
5887}
5888
5889/// Struct expression
5890#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5891#[cfg_attr(feature = "bindings", derive(TS))]
5892pub struct Struct {
5893    pub fields: Vec<(Option<String>, Expression)>,
5894}
5895
5896/// Tuple expression
5897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5898#[cfg_attr(feature = "bindings", derive(TS))]
5899pub struct Tuple {
5900    pub expressions: Vec<Expression>,
5901}
5902
5903/// Interval expression
5904#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5905#[cfg_attr(feature = "bindings", derive(TS))]
5906pub struct Interval {
5907    /// The value expression (e.g., '1', 5, column_ref)
5908    pub this: Option<Expression>,
5909    /// The unit specification (optional - can be None, a simple unit, a span, or an expression)
5910    pub unit: Option<IntervalUnitSpec>,
5911}
5912
5913/// Specification for interval unit - can be a simple unit, a span (HOUR TO SECOND), or an expression
5914#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5915#[cfg_attr(feature = "bindings", derive(TS))]
5916#[serde(tag = "type", rename_all = "snake_case")]
5917pub enum IntervalUnitSpec {
5918    /// Simple interval unit (YEAR, MONTH, DAY, etc.)
5919    Simple {
5920        unit: IntervalUnit,
5921        /// Whether to use plural form (e.g., DAYS vs DAY)
5922        use_plural: bool,
5923    },
5924    /// Interval span (e.g., HOUR TO SECOND)
5925    Span(IntervalSpan),
5926    /// Expression-based interval span for Oracle (e.g., DAY(9) TO SECOND(3))
5927    /// The start and end can be expressions like function calls with precision
5928    ExprSpan(IntervalSpanExpr),
5929    /// Expression as unit (e.g., CURRENT_DATE, CAST(GETDATE() AS DATE))
5930    Expr(Box<Expression>),
5931}
5932
5933/// Interval span for ranges like HOUR TO SECOND
5934#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5935#[cfg_attr(feature = "bindings", derive(TS))]
5936pub struct IntervalSpan {
5937    /// Start unit (e.g., HOUR)
5938    pub this: IntervalUnit,
5939    /// End unit (e.g., SECOND)
5940    pub expression: IntervalUnit,
5941}
5942
5943/// Expression-based interval span for Oracle (e.g., DAY(9) TO SECOND(3))
5944/// Unlike IntervalSpan, this uses expressions to represent units with optional precision
5945#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5946#[cfg_attr(feature = "bindings", derive(TS))]
5947pub struct IntervalSpanExpr {
5948    /// Start unit expression (e.g., Var("DAY") or Anonymous("DAY", [9]))
5949    pub this: Box<Expression>,
5950    /// End unit expression (e.g., Var("SECOND") or Anonymous("SECOND", [3]))
5951    pub expression: Box<Expression>,
5952}
5953
5954#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
5955#[cfg_attr(feature = "bindings", derive(TS))]
5956pub enum IntervalUnit {
5957    Year,
5958    Quarter,
5959    Month,
5960    Week,
5961    Day,
5962    Hour,
5963    Minute,
5964    Second,
5965    Millisecond,
5966    Microsecond,
5967    Nanosecond,
5968}
5969
5970/// SQL Command (COMMIT, ROLLBACK, BEGIN, etc.)
5971#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5972#[cfg_attr(feature = "bindings", derive(TS))]
5973pub struct Command {
5974    /// The command text (e.g., "ROLLBACK", "COMMIT", "BEGIN")
5975    pub this: String,
5976}
5977
5978/// EXEC/EXECUTE statement (TSQL stored procedure call)
5979/// Syntax: EXEC [schema.]procedure_name [@param=value, ...]
5980#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5981#[cfg_attr(feature = "bindings", derive(TS))]
5982pub struct ExecuteStatement {
5983    /// The procedure name (can be qualified: schema.proc_name)
5984    pub this: Expression,
5985    /// Named parameters: @param=value pairs
5986    #[serde(default)]
5987    pub parameters: Vec<ExecuteParameter>,
5988    /// Trailing clause text (e.g. WITH RESULT SETS ((...)))
5989    #[serde(default, skip_serializing_if = "Option::is_none")]
5990    pub suffix: Option<String>,
5991}
5992
5993/// Named parameter in EXEC statement: @name=value
5994#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5995#[cfg_attr(feature = "bindings", derive(TS))]
5996pub struct ExecuteParameter {
5997    /// Parameter name (including @)
5998    pub name: String,
5999    /// Parameter value
6000    pub value: Expression,
6001    /// Whether this is a positional parameter (no = sign)
6002    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
6003    pub positional: bool,
6004    /// TSQL OUTPUT modifier on parameter
6005    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
6006    pub output: bool,
6007}
6008
6009/// KILL statement (MySQL/MariaDB)
6010/// KILL [CONNECTION | QUERY] <id>
6011#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6012#[cfg_attr(feature = "bindings", derive(TS))]
6013pub struct Kill {
6014    /// The target (process ID or connection ID)
6015    pub this: Expression,
6016    /// Optional kind: "CONNECTION" or "QUERY"
6017    pub kind: Option<String>,
6018}
6019
6020/// Snowflake CREATE TASK statement
6021#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6022#[cfg_attr(feature = "bindings", derive(TS))]
6023pub struct CreateTask {
6024    pub or_replace: bool,
6025    pub if_not_exists: bool,
6026    /// Task name (possibly qualified: db.schema.task)
6027    pub name: String,
6028    /// Raw text of properties between name and AS (WAREHOUSE, SCHEDULE, etc.)
6029    pub properties: String,
6030    /// The SQL statement body after AS
6031    pub body: Expression,
6032}
6033
6034/// Raw/unparsed SQL
6035#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6036#[cfg_attr(feature = "bindings", derive(TS))]
6037pub struct Raw {
6038    pub sql: String,
6039}
6040
6041// ============================================================================
6042// Function expression types
6043// ============================================================================
6044
6045/// Generic unary function (takes a single argument)
6046#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6047#[cfg_attr(feature = "bindings", derive(TS))]
6048pub struct UnaryFunc {
6049    pub this: Expression,
6050    /// Original function name for round-trip preservation (e.g., CHAR_LENGTH vs LENGTH)
6051    #[serde(skip_serializing_if = "Option::is_none", default)]
6052    pub original_name: Option<String>,
6053    /// Inferred data type from type annotation
6054    #[serde(default, skip_serializing_if = "Option::is_none")]
6055    pub inferred_type: Option<DataType>,
6056}
6057
6058impl UnaryFunc {
6059    /// Create a new UnaryFunc with no original_name
6060    pub fn new(this: Expression) -> Self {
6061        Self {
6062            this,
6063            original_name: None,
6064            inferred_type: None,
6065        }
6066    }
6067
6068    /// Create a new UnaryFunc with an original name for round-trip preservation
6069    pub fn with_name(this: Expression, name: String) -> Self {
6070        Self {
6071            this,
6072            original_name: Some(name),
6073            inferred_type: None,
6074        }
6075    }
6076}
6077
6078/// CHAR/CHR function with multiple args and optional USING charset
6079/// e.g., CHAR(77, 77.3, '77.3' USING utf8mb4)
6080/// e.g., CHR(187 USING NCHAR_CS) -- Oracle
6081#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6082#[cfg_attr(feature = "bindings", derive(TS))]
6083pub struct CharFunc {
6084    pub args: Vec<Expression>,
6085    #[serde(skip_serializing_if = "Option::is_none", default)]
6086    pub charset: Option<String>,
6087    /// Original function name (CHAR or CHR), defaults to CHAR
6088    #[serde(skip_serializing_if = "Option::is_none", default)]
6089    pub name: Option<String>,
6090}
6091
6092/// Generic binary function (takes two arguments)
6093#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6094#[cfg_attr(feature = "bindings", derive(TS))]
6095pub struct BinaryFunc {
6096    pub this: Expression,
6097    pub expression: Expression,
6098    /// Original function name for round-trip preservation (e.g., NVL vs IFNULL)
6099    #[serde(skip_serializing_if = "Option::is_none", default)]
6100    pub original_name: Option<String>,
6101    /// Inferred data type from type annotation
6102    #[serde(default, skip_serializing_if = "Option::is_none")]
6103    pub inferred_type: Option<DataType>,
6104}
6105
6106/// Variable argument function
6107#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6108#[cfg_attr(feature = "bindings", derive(TS))]
6109pub struct VarArgFunc {
6110    pub expressions: Vec<Expression>,
6111    /// Original function name for round-trip preservation (e.g., COALESCE vs IFNULL)
6112    #[serde(skip_serializing_if = "Option::is_none", default)]
6113    pub original_name: Option<String>,
6114    /// Inferred data type from type annotation
6115    #[serde(default, skip_serializing_if = "Option::is_none")]
6116    pub inferred_type: Option<DataType>,
6117}
6118
6119/// CONCAT_WS function
6120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6121#[cfg_attr(feature = "bindings", derive(TS))]
6122pub struct ConcatWs {
6123    pub separator: Expression,
6124    pub expressions: Vec<Expression>,
6125}
6126
6127/// SUBSTRING function
6128#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6129#[cfg_attr(feature = "bindings", derive(TS))]
6130pub struct SubstringFunc {
6131    pub this: Expression,
6132    pub start: Expression,
6133    pub length: Option<Expression>,
6134    /// Whether SQL standard FROM/FOR syntax was used (true) vs comma-separated (false)
6135    #[serde(default)]
6136    pub from_for_syntax: bool,
6137}
6138
6139/// OVERLAY function - OVERLAY(string PLACING replacement FROM position [FOR length])
6140#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6141#[cfg_attr(feature = "bindings", derive(TS))]
6142pub struct OverlayFunc {
6143    pub this: Expression,
6144    pub replacement: Expression,
6145    pub from: Expression,
6146    pub length: Option<Expression>,
6147}
6148
6149/// TRIM function
6150#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6151#[cfg_attr(feature = "bindings", derive(TS))]
6152pub struct TrimFunc {
6153    pub this: Expression,
6154    pub characters: Option<Expression>,
6155    pub position: TrimPosition,
6156    /// Whether SQL standard syntax was used (TRIM(BOTH chars FROM str)) vs function syntax (TRIM(str))
6157    #[serde(default)]
6158    pub sql_standard_syntax: bool,
6159    /// Whether the position was explicitly specified (BOTH/LEADING/TRAILING) vs defaulted
6160    #[serde(default)]
6161    pub position_explicit: bool,
6162}
6163
6164#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6165#[cfg_attr(feature = "bindings", derive(TS))]
6166pub enum TrimPosition {
6167    Both,
6168    Leading,
6169    Trailing,
6170}
6171
6172/// REPLACE function
6173#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6174#[cfg_attr(feature = "bindings", derive(TS))]
6175pub struct ReplaceFunc {
6176    pub this: Expression,
6177    pub old: Expression,
6178    pub new: Expression,
6179}
6180
6181/// LEFT/RIGHT function
6182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6183#[cfg_attr(feature = "bindings", derive(TS))]
6184pub struct LeftRightFunc {
6185    pub this: Expression,
6186    pub length: Expression,
6187}
6188
6189/// REPEAT function
6190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6191#[cfg_attr(feature = "bindings", derive(TS))]
6192pub struct RepeatFunc {
6193    pub this: Expression,
6194    pub times: Expression,
6195}
6196
6197/// LPAD/RPAD function
6198#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6199#[cfg_attr(feature = "bindings", derive(TS))]
6200pub struct PadFunc {
6201    pub this: Expression,
6202    pub length: Expression,
6203    pub fill: Option<Expression>,
6204}
6205
6206/// SPLIT function
6207#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6208#[cfg_attr(feature = "bindings", derive(TS))]
6209pub struct SplitFunc {
6210    pub this: Expression,
6211    pub delimiter: Expression,
6212}
6213
6214/// REGEXP_LIKE function
6215#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6216#[cfg_attr(feature = "bindings", derive(TS))]
6217pub struct RegexpFunc {
6218    pub this: Expression,
6219    pub pattern: Expression,
6220    pub flags: Option<Expression>,
6221}
6222
6223/// REGEXP_REPLACE function
6224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6225#[cfg_attr(feature = "bindings", derive(TS))]
6226pub struct RegexpReplaceFunc {
6227    pub this: Expression,
6228    pub pattern: Expression,
6229    pub replacement: Expression,
6230    pub flags: Option<Expression>,
6231}
6232
6233/// REGEXP_EXTRACT function
6234#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6235#[cfg_attr(feature = "bindings", derive(TS))]
6236pub struct RegexpExtractFunc {
6237    pub this: Expression,
6238    pub pattern: Expression,
6239    pub group: Option<Expression>,
6240}
6241
6242/// ROUND function
6243#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6244#[cfg_attr(feature = "bindings", derive(TS))]
6245pub struct RoundFunc {
6246    pub this: Expression,
6247    pub decimals: Option<Expression>,
6248}
6249
6250/// FLOOR function with optional scale and time unit (Druid: FLOOR(time TO unit))
6251#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6252#[cfg_attr(feature = "bindings", derive(TS))]
6253pub struct FloorFunc {
6254    pub this: Expression,
6255    pub scale: Option<Expression>,
6256    /// Time unit for Druid-style FLOOR(time TO unit) syntax
6257    #[serde(skip_serializing_if = "Option::is_none", default)]
6258    pub to: Option<Expression>,
6259}
6260
6261/// CEIL function with optional decimals and time unit (Druid: CEIL(time TO unit))
6262#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6263#[cfg_attr(feature = "bindings", derive(TS))]
6264pub struct CeilFunc {
6265    pub this: Expression,
6266    #[serde(skip_serializing_if = "Option::is_none", default)]
6267    pub decimals: Option<Expression>,
6268    /// Time unit for Druid-style CEIL(time TO unit) syntax
6269    #[serde(skip_serializing_if = "Option::is_none", default)]
6270    pub to: Option<Expression>,
6271}
6272
6273/// LOG function
6274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6275#[cfg_attr(feature = "bindings", derive(TS))]
6276pub struct LogFunc {
6277    pub this: Expression,
6278    pub base: Option<Expression>,
6279}
6280
6281/// CURRENT_DATE (no arguments)
6282#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6283#[cfg_attr(feature = "bindings", derive(TS))]
6284pub struct CurrentDate;
6285
6286/// CURRENT_TIME
6287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6288#[cfg_attr(feature = "bindings", derive(TS))]
6289pub struct CurrentTime {
6290    pub precision: Option<u32>,
6291}
6292
6293/// CURRENT_TIMESTAMP
6294#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6295#[cfg_attr(feature = "bindings", derive(TS))]
6296pub struct CurrentTimestamp {
6297    pub precision: Option<u32>,
6298    /// If true, generate SYSDATE instead of CURRENT_TIMESTAMP (Oracle-specific)
6299    #[serde(default)]
6300    pub sysdate: bool,
6301}
6302
6303/// CURRENT_TIMESTAMP_LTZ - Snowflake local timezone timestamp
6304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6305#[cfg_attr(feature = "bindings", derive(TS))]
6306pub struct CurrentTimestampLTZ {
6307    pub precision: Option<u32>,
6308}
6309
6310/// AT TIME ZONE expression for timezone conversion
6311#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6312#[cfg_attr(feature = "bindings", derive(TS))]
6313pub struct AtTimeZone {
6314    /// The expression to convert
6315    pub this: Expression,
6316    /// The target timezone
6317    pub zone: Expression,
6318}
6319
6320/// DATE_ADD / DATE_SUB function
6321#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6322#[cfg_attr(feature = "bindings", derive(TS))]
6323pub struct DateAddFunc {
6324    pub this: Expression,
6325    pub interval: Expression,
6326    pub unit: IntervalUnit,
6327}
6328
6329/// DATEDIFF function
6330#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6331#[cfg_attr(feature = "bindings", derive(TS))]
6332pub struct DateDiffFunc {
6333    pub this: Expression,
6334    pub expression: Expression,
6335    pub unit: Option<IntervalUnit>,
6336}
6337
6338/// DATE_TRUNC function
6339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6340#[cfg_attr(feature = "bindings", derive(TS))]
6341pub struct DateTruncFunc {
6342    pub this: Expression,
6343    pub unit: DateTimeField,
6344}
6345
6346/// EXTRACT function
6347#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6348#[cfg_attr(feature = "bindings", derive(TS))]
6349pub struct ExtractFunc {
6350    pub this: Expression,
6351    pub field: DateTimeField,
6352}
6353
6354#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
6355#[cfg_attr(feature = "bindings", derive(TS))]
6356pub enum DateTimeField {
6357    Year,
6358    Month,
6359    Day,
6360    Hour,
6361    Minute,
6362    Second,
6363    Millisecond,
6364    Microsecond,
6365    DayOfWeek,
6366    DayOfYear,
6367    Week,
6368    /// Week with a modifier like WEEK(monday), WEEK(sunday)
6369    WeekWithModifier(String),
6370    Quarter,
6371    Epoch,
6372    Timezone,
6373    TimezoneHour,
6374    TimezoneMinute,
6375    Date,
6376    Time,
6377    /// Custom datetime field for dialect-specific or arbitrary fields
6378    Custom(String),
6379}
6380
6381/// TO_DATE function
6382#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6383#[cfg_attr(feature = "bindings", derive(TS))]
6384pub struct ToDateFunc {
6385    pub this: Expression,
6386    pub format: Option<Expression>,
6387}
6388
6389/// TO_TIMESTAMP function
6390#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6391#[cfg_attr(feature = "bindings", derive(TS))]
6392pub struct ToTimestampFunc {
6393    pub this: Expression,
6394    pub format: Option<Expression>,
6395}
6396
6397/// IF function
6398#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6399#[cfg_attr(feature = "bindings", derive(TS))]
6400pub struct IfFunc {
6401    pub condition: Expression,
6402    pub true_value: Expression,
6403    pub false_value: Option<Expression>,
6404    /// Original function name (IF, IFF, IIF) for round-trip preservation
6405    #[serde(skip_serializing_if = "Option::is_none", default)]
6406    pub original_name: Option<String>,
6407    /// Inferred data type from type annotation
6408    #[serde(default, skip_serializing_if = "Option::is_none")]
6409    pub inferred_type: Option<DataType>,
6410}
6411
6412/// NVL2 function
6413#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6414#[cfg_attr(feature = "bindings", derive(TS))]
6415pub struct Nvl2Func {
6416    pub this: Expression,
6417    pub true_value: Expression,
6418    pub false_value: Expression,
6419    /// Inferred data type from type annotation
6420    #[serde(default, skip_serializing_if = "Option::is_none")]
6421    pub inferred_type: Option<DataType>,
6422}
6423
6424// ============================================================================
6425// Typed Aggregate Function types
6426// ============================================================================
6427
6428/// Generic aggregate function base type
6429#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6430#[cfg_attr(feature = "bindings", derive(TS))]
6431pub struct AggFunc {
6432    pub this: Expression,
6433    pub distinct: bool,
6434    pub filter: Option<Expression>,
6435    pub order_by: Vec<Ordered>,
6436    /// Original function name (case-preserving) when parsed from SQL
6437    #[serde(skip_serializing_if = "Option::is_none", default)]
6438    pub name: Option<String>,
6439    /// IGNORE NULLS (true) or RESPECT NULLS (false), None if not specified
6440    #[serde(skip_serializing_if = "Option::is_none", default)]
6441    pub ignore_nulls: Option<bool>,
6442    /// HAVING MAX/MIN expr inside aggregate (BigQuery syntax)
6443    /// e.g., ANY_VALUE(fruit HAVING MAX sold) - (expression, is_max: true for MAX, false for MIN)
6444    #[serde(skip_serializing_if = "Option::is_none", default)]
6445    pub having_max: Option<(Box<Expression>, bool)>,
6446    /// LIMIT inside aggregate (e.g., ARRAY_AGG(x ORDER BY y LIMIT 2))
6447    #[serde(skip_serializing_if = "Option::is_none", default)]
6448    pub limit: Option<Box<Expression>>,
6449    /// Inferred data type from type annotation
6450    #[serde(default, skip_serializing_if = "Option::is_none")]
6451    pub inferred_type: Option<DataType>,
6452}
6453
6454/// COUNT function with optional star
6455#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6456#[cfg_attr(feature = "bindings", derive(TS))]
6457pub struct CountFunc {
6458    pub this: Option<Expression>,
6459    pub star: bool,
6460    pub distinct: bool,
6461    pub filter: Option<Expression>,
6462    /// IGNORE NULLS (true) or RESPECT NULLS (false)
6463    #[serde(default, skip_serializing_if = "Option::is_none")]
6464    pub ignore_nulls: Option<bool>,
6465    /// Original function name for case preservation (e.g., "count" or "COUNT")
6466    #[serde(default, skip_serializing_if = "Option::is_none")]
6467    pub original_name: Option<String>,
6468    /// Inferred data type from type annotation
6469    #[serde(default, skip_serializing_if = "Option::is_none")]
6470    pub inferred_type: Option<DataType>,
6471}
6472
6473/// GROUP_CONCAT function (MySQL style)
6474#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6475#[cfg_attr(feature = "bindings", derive(TS))]
6476pub struct GroupConcatFunc {
6477    pub this: Expression,
6478    pub separator: Option<Expression>,
6479    pub order_by: Option<Vec<Ordered>>,
6480    pub distinct: bool,
6481    pub filter: Option<Expression>,
6482    /// Inferred data type from type annotation
6483    #[serde(default, skip_serializing_if = "Option::is_none")]
6484    pub inferred_type: Option<DataType>,
6485}
6486
6487/// STRING_AGG function (PostgreSQL/Standard SQL)
6488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6489#[cfg_attr(feature = "bindings", derive(TS))]
6490pub struct StringAggFunc {
6491    pub this: Expression,
6492    #[serde(default)]
6493    pub separator: Option<Expression>,
6494    #[serde(default)]
6495    pub order_by: Option<Vec<Ordered>>,
6496    #[serde(default)]
6497    pub distinct: bool,
6498    #[serde(default)]
6499    pub filter: Option<Expression>,
6500    /// BigQuery LIMIT inside STRING_AGG
6501    #[serde(default, skip_serializing_if = "Option::is_none")]
6502    pub limit: Option<Box<Expression>>,
6503    /// Inferred data type from type annotation
6504    #[serde(default, skip_serializing_if = "Option::is_none")]
6505    pub inferred_type: Option<DataType>,
6506}
6507
6508/// LISTAGG function (Oracle style)
6509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6510#[cfg_attr(feature = "bindings", derive(TS))]
6511pub struct ListAggFunc {
6512    pub this: Expression,
6513    pub separator: Option<Expression>,
6514    pub on_overflow: Option<ListAggOverflow>,
6515    pub order_by: Option<Vec<Ordered>>,
6516    pub distinct: bool,
6517    pub filter: Option<Expression>,
6518    /// Inferred data type from type annotation
6519    #[serde(default, skip_serializing_if = "Option::is_none")]
6520    pub inferred_type: Option<DataType>,
6521}
6522
6523/// LISTAGG ON OVERFLOW behavior
6524#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6525#[cfg_attr(feature = "bindings", derive(TS))]
6526pub enum ListAggOverflow {
6527    Error,
6528    Truncate {
6529        filler: Option<Expression>,
6530        with_count: bool,
6531    },
6532}
6533
6534/// SUM_IF / COUNT_IF function
6535#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6536#[cfg_attr(feature = "bindings", derive(TS))]
6537pub struct SumIfFunc {
6538    pub this: Expression,
6539    pub condition: Expression,
6540    pub filter: Option<Expression>,
6541    /// Inferred data type from type annotation
6542    #[serde(default, skip_serializing_if = "Option::is_none")]
6543    pub inferred_type: Option<DataType>,
6544}
6545
6546/// APPROX_PERCENTILE function
6547#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6548#[cfg_attr(feature = "bindings", derive(TS))]
6549pub struct ApproxPercentileFunc {
6550    pub this: Expression,
6551    pub percentile: Expression,
6552    pub accuracy: Option<Expression>,
6553    pub filter: Option<Expression>,
6554}
6555
6556/// PERCENTILE_CONT / PERCENTILE_DISC function
6557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6558#[cfg_attr(feature = "bindings", derive(TS))]
6559pub struct PercentileFunc {
6560    pub this: Expression,
6561    pub percentile: Expression,
6562    pub order_by: Option<Vec<Ordered>>,
6563    pub filter: Option<Expression>,
6564}
6565
6566// ============================================================================
6567// Typed Window Function types
6568// ============================================================================
6569
6570/// ROW_NUMBER function (no arguments)
6571#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6572#[cfg_attr(feature = "bindings", derive(TS))]
6573pub struct RowNumber;
6574
6575/// RANK function (DuckDB allows ORDER BY inside, Oracle allows hypothetical args with WITHIN GROUP)
6576#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6577#[cfg_attr(feature = "bindings", derive(TS))]
6578pub struct Rank {
6579    /// DuckDB: RANK(ORDER BY col) - order by inside function
6580    #[serde(default, skip_serializing_if = "Option::is_none")]
6581    pub order_by: Option<Vec<Ordered>>,
6582    /// Oracle hypothetical rank: RANK(val1, val2, ...) WITHIN GROUP (ORDER BY ...)
6583    #[serde(default, skip_serializing_if = "Vec::is_empty")]
6584    pub args: Vec<Expression>,
6585}
6586
6587/// DENSE_RANK function (Oracle allows hypothetical args with WITHIN GROUP)
6588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6589#[cfg_attr(feature = "bindings", derive(TS))]
6590pub struct DenseRank {
6591    /// Oracle hypothetical rank: DENSE_RANK(val1, val2, ...) WITHIN GROUP (ORDER BY ...)
6592    #[serde(default, skip_serializing_if = "Vec::is_empty")]
6593    pub args: Vec<Expression>,
6594}
6595
6596/// NTILE function (DuckDB allows ORDER BY inside)
6597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6598#[cfg_attr(feature = "bindings", derive(TS))]
6599pub struct NTileFunc {
6600    /// num_buckets is optional to support Databricks NTILE() without arguments
6601    #[serde(default, skip_serializing_if = "Option::is_none")]
6602    pub num_buckets: Option<Expression>,
6603    /// DuckDB: NTILE(n ORDER BY col) - order by inside function
6604    #[serde(default, skip_serializing_if = "Option::is_none")]
6605    pub order_by: Option<Vec<Ordered>>,
6606}
6607
6608/// LEAD / LAG function
6609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6610#[cfg_attr(feature = "bindings", derive(TS))]
6611pub struct LeadLagFunc {
6612    pub this: Expression,
6613    pub offset: Option<Expression>,
6614    pub default: Option<Expression>,
6615    /// None = not specified, Some(true) = IGNORE NULLS, Some(false) = RESPECT NULLS
6616    #[serde(default, skip_serializing_if = "Option::is_none")]
6617    pub ignore_nulls: Option<bool>,
6618}
6619
6620/// FIRST_VALUE / LAST_VALUE function
6621#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6622#[cfg_attr(feature = "bindings", derive(TS))]
6623pub struct ValueFunc {
6624    pub this: Expression,
6625    /// None = not specified, Some(true) = IGNORE NULLS, Some(false) = RESPECT NULLS
6626    #[serde(default, skip_serializing_if = "Option::is_none")]
6627    pub ignore_nulls: Option<bool>,
6628    /// ORDER BY inside the function parens (e.g., DuckDB: LAST_VALUE(x ORDER BY x))
6629    #[serde(default, skip_serializing_if = "Vec::is_empty")]
6630    pub order_by: Vec<Ordered>,
6631}
6632
6633/// NTH_VALUE function
6634#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6635#[cfg_attr(feature = "bindings", derive(TS))]
6636pub struct NthValueFunc {
6637    pub this: Expression,
6638    pub offset: Expression,
6639    /// None = not specified, Some(true) = IGNORE NULLS, Some(false) = RESPECT NULLS
6640    #[serde(default, skip_serializing_if = "Option::is_none")]
6641    pub ignore_nulls: Option<bool>,
6642    /// Snowflake FROM FIRST / FROM LAST clause
6643    /// None = not specified, Some(true) = FROM FIRST, Some(false) = FROM LAST
6644    #[serde(default, skip_serializing_if = "Option::is_none")]
6645    pub from_first: Option<bool>,
6646}
6647
6648/// PERCENT_RANK function (DuckDB allows ORDER BY inside, Oracle allows hypothetical args with WITHIN GROUP)
6649#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6650#[cfg_attr(feature = "bindings", derive(TS))]
6651pub struct PercentRank {
6652    /// DuckDB: PERCENT_RANK(ORDER BY col) - order by inside function
6653    #[serde(default, skip_serializing_if = "Option::is_none")]
6654    pub order_by: Option<Vec<Ordered>>,
6655    /// Oracle hypothetical rank: PERCENT_RANK(val1, val2, ...) WITHIN GROUP (ORDER BY ...)
6656    #[serde(default, skip_serializing_if = "Vec::is_empty")]
6657    pub args: Vec<Expression>,
6658}
6659
6660/// CUME_DIST function (DuckDB allows ORDER BY inside, Oracle allows hypothetical args with WITHIN GROUP)
6661#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6662#[cfg_attr(feature = "bindings", derive(TS))]
6663pub struct CumeDist {
6664    /// DuckDB: CUME_DIST(ORDER BY col) - order by inside function
6665    #[serde(default, skip_serializing_if = "Option::is_none")]
6666    pub order_by: Option<Vec<Ordered>>,
6667    /// Oracle hypothetical rank: CUME_DIST(val1, val2, ...) WITHIN GROUP (ORDER BY ...)
6668    #[serde(default, skip_serializing_if = "Vec::is_empty")]
6669    pub args: Vec<Expression>,
6670}
6671
6672// ============================================================================
6673// Additional String Function types
6674// ============================================================================
6675
6676/// POSITION/INSTR function
6677#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6678#[cfg_attr(feature = "bindings", derive(TS))]
6679pub struct PositionFunc {
6680    pub substring: Expression,
6681    pub string: Expression,
6682    pub start: Option<Expression>,
6683}
6684
6685// ============================================================================
6686// Additional Math Function types
6687// ============================================================================
6688
6689/// RANDOM function (no arguments)
6690#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6691#[cfg_attr(feature = "bindings", derive(TS))]
6692pub struct Random;
6693
6694/// RAND function (optional seed, or Teradata RANDOM(lower, upper))
6695#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6696#[cfg_attr(feature = "bindings", derive(TS))]
6697pub struct Rand {
6698    pub seed: Option<Box<Expression>>,
6699    /// Teradata RANDOM lower bound
6700    #[serde(default)]
6701    pub lower: Option<Box<Expression>>,
6702    /// Teradata RANDOM upper bound
6703    #[serde(default)]
6704    pub upper: Option<Box<Expression>>,
6705}
6706
6707/// TRUNCATE / TRUNC function
6708#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6709#[cfg_attr(feature = "bindings", derive(TS))]
6710pub struct TruncateFunc {
6711    pub this: Expression,
6712    pub decimals: Option<Expression>,
6713}
6714
6715/// PI function (no arguments)
6716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6717#[cfg_attr(feature = "bindings", derive(TS))]
6718pub struct Pi;
6719
6720// ============================================================================
6721// Control Flow Function types
6722// ============================================================================
6723
6724/// DECODE function (Oracle style)
6725#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6726#[cfg_attr(feature = "bindings", derive(TS))]
6727pub struct DecodeFunc {
6728    pub this: Expression,
6729    pub search_results: Vec<(Expression, Expression)>,
6730    pub default: Option<Expression>,
6731}
6732
6733// ============================================================================
6734// Additional Date/Time Function types
6735// ============================================================================
6736
6737/// DATE_FORMAT / FORMAT_DATE function
6738#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6739#[cfg_attr(feature = "bindings", derive(TS))]
6740pub struct DateFormatFunc {
6741    pub this: Expression,
6742    pub format: Expression,
6743}
6744
6745/// FROM_UNIXTIME function
6746#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6747#[cfg_attr(feature = "bindings", derive(TS))]
6748pub struct FromUnixtimeFunc {
6749    pub this: Expression,
6750    pub format: Option<Expression>,
6751}
6752
6753/// UNIX_TIMESTAMP function
6754#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6755#[cfg_attr(feature = "bindings", derive(TS))]
6756pub struct UnixTimestampFunc {
6757    pub this: Option<Expression>,
6758    pub format: Option<Expression>,
6759}
6760
6761/// MAKE_DATE function
6762#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6763#[cfg_attr(feature = "bindings", derive(TS))]
6764pub struct MakeDateFunc {
6765    pub year: Expression,
6766    pub month: Expression,
6767    pub day: Expression,
6768}
6769
6770/// MAKE_TIMESTAMP function
6771#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6772#[cfg_attr(feature = "bindings", derive(TS))]
6773pub struct MakeTimestampFunc {
6774    pub year: Expression,
6775    pub month: Expression,
6776    pub day: Expression,
6777    pub hour: Expression,
6778    pub minute: Expression,
6779    pub second: Expression,
6780    pub timezone: Option<Expression>,
6781}
6782
6783/// LAST_DAY function with optional date part (for BigQuery granularity like WEEK(SUNDAY))
6784#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6785#[cfg_attr(feature = "bindings", derive(TS))]
6786pub struct LastDayFunc {
6787    pub this: Expression,
6788    /// Optional date part for granularity (e.g., MONTH, YEAR, WEEK(SUNDAY))
6789    #[serde(skip_serializing_if = "Option::is_none", default)]
6790    pub unit: Option<DateTimeField>,
6791}
6792
6793// ============================================================================
6794// Array Function types
6795// ============================================================================
6796
6797/// ARRAY constructor
6798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6799#[cfg_attr(feature = "bindings", derive(TS))]
6800pub struct ArrayConstructor {
6801    pub expressions: Vec<Expression>,
6802    pub bracket_notation: bool,
6803    /// True if LIST keyword was used instead of ARRAY (DuckDB)
6804    pub use_list_keyword: bool,
6805}
6806
6807/// ARRAY_SORT function
6808#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6809#[cfg_attr(feature = "bindings", derive(TS))]
6810pub struct ArraySortFunc {
6811    pub this: Expression,
6812    pub comparator: Option<Expression>,
6813    pub desc: bool,
6814    pub nulls_first: Option<bool>,
6815}
6816
6817/// ARRAY_JOIN / ARRAY_TO_STRING function
6818#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6819#[cfg_attr(feature = "bindings", derive(TS))]
6820pub struct ArrayJoinFunc {
6821    pub this: Expression,
6822    pub separator: Expression,
6823    pub null_replacement: Option<Expression>,
6824}
6825
6826/// UNNEST function
6827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6828#[cfg_attr(feature = "bindings", derive(TS))]
6829pub struct UnnestFunc {
6830    pub this: Expression,
6831    /// Additional arguments for multi-argument UNNEST (e.g., UNNEST(arr1, arr2))
6832    #[serde(default, skip_serializing_if = "Vec::is_empty")]
6833    pub expressions: Vec<Expression>,
6834    pub with_ordinality: bool,
6835    pub alias: Option<Identifier>,
6836    /// BigQuery: offset alias for WITH OFFSET AS <name>
6837    #[serde(default, skip_serializing_if = "Option::is_none")]
6838    pub offset_alias: Option<Identifier>,
6839}
6840
6841/// ARRAY_FILTER function (with lambda)
6842#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6843#[cfg_attr(feature = "bindings", derive(TS))]
6844pub struct ArrayFilterFunc {
6845    pub this: Expression,
6846    pub filter: Expression,
6847}
6848
6849/// ARRAY_TRANSFORM / TRANSFORM function (with lambda)
6850#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6851#[cfg_attr(feature = "bindings", derive(TS))]
6852pub struct ArrayTransformFunc {
6853    pub this: Expression,
6854    pub transform: Expression,
6855}
6856
6857/// SEQUENCE / GENERATE_SERIES function
6858#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6859#[cfg_attr(feature = "bindings", derive(TS))]
6860pub struct SequenceFunc {
6861    pub start: Expression,
6862    pub stop: Expression,
6863    pub step: Option<Expression>,
6864}
6865
6866// ============================================================================
6867// Struct Function types
6868// ============================================================================
6869
6870/// STRUCT constructor
6871#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6872#[cfg_attr(feature = "bindings", derive(TS))]
6873pub struct StructConstructor {
6874    pub fields: Vec<(Option<Identifier>, Expression)>,
6875}
6876
6877/// STRUCT_EXTRACT function
6878#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6879#[cfg_attr(feature = "bindings", derive(TS))]
6880pub struct StructExtractFunc {
6881    pub this: Expression,
6882    pub field: Identifier,
6883}
6884
6885/// NAMED_STRUCT function
6886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6887#[cfg_attr(feature = "bindings", derive(TS))]
6888pub struct NamedStructFunc {
6889    pub pairs: Vec<(Expression, Expression)>,
6890}
6891
6892// ============================================================================
6893// Map Function types
6894// ============================================================================
6895
6896/// MAP constructor
6897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6898#[cfg_attr(feature = "bindings", derive(TS))]
6899pub struct MapConstructor {
6900    pub keys: Vec<Expression>,
6901    pub values: Vec<Expression>,
6902    /// Whether curly brace syntax was used (`{'a': 1}`) vs MAP function (`MAP(...)`)
6903    #[serde(default)]
6904    pub curly_brace_syntax: bool,
6905    /// Whether MAP keyword was present (`MAP {'a': 1}`) vs bare curly braces (`{'a': 1}`)
6906    #[serde(default)]
6907    pub with_map_keyword: bool,
6908}
6909
6910/// TRANSFORM_KEYS / TRANSFORM_VALUES function
6911#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6912#[cfg_attr(feature = "bindings", derive(TS))]
6913pub struct TransformFunc {
6914    pub this: Expression,
6915    pub transform: Expression,
6916}
6917
6918/// Function call with EMITS clause (Exasol)
6919/// Used for JSON_EXTRACT(...) EMITS (col1 TYPE1, col2 TYPE2)
6920#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6921#[cfg_attr(feature = "bindings", derive(TS))]
6922pub struct FunctionEmits {
6923    /// The function call expression
6924    pub this: Expression,
6925    /// The EMITS schema definition
6926    pub emits: Expression,
6927}
6928
6929// ============================================================================
6930// JSON Function types
6931// ============================================================================
6932
6933/// JSON_EXTRACT / JSON_EXTRACT_SCALAR function
6934#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6935#[cfg_attr(feature = "bindings", derive(TS))]
6936pub struct JsonExtractFunc {
6937    pub this: Expression,
6938    pub path: Expression,
6939    pub returning: Option<DataType>,
6940    /// True if parsed from -> or ->> operator syntax
6941    #[serde(default)]
6942    pub arrow_syntax: bool,
6943    /// True if parsed from #>> operator syntax (PostgreSQL JSONB path text extraction)
6944    #[serde(default)]
6945    pub hash_arrow_syntax: bool,
6946    /// Wrapper option: WITH/WITHOUT [CONDITIONAL|UNCONDITIONAL] [ARRAY] WRAPPER
6947    #[serde(default)]
6948    pub wrapper_option: Option<String>,
6949    /// Quotes handling: KEEP QUOTES or OMIT QUOTES
6950    #[serde(default)]
6951    pub quotes_option: Option<String>,
6952    /// ON SCALAR STRING flag
6953    #[serde(default)]
6954    pub on_scalar_string: bool,
6955    /// Error handling: NULL ON ERROR, ERROR ON ERROR, etc.
6956    #[serde(default)]
6957    pub on_error: Option<String>,
6958}
6959
6960/// JSON path extraction
6961#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6962#[cfg_attr(feature = "bindings", derive(TS))]
6963pub struct JsonPathFunc {
6964    pub this: Expression,
6965    pub paths: Vec<Expression>,
6966}
6967
6968/// JSON_OBJECT function
6969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6970#[cfg_attr(feature = "bindings", derive(TS))]
6971pub struct JsonObjectFunc {
6972    pub pairs: Vec<(Expression, Expression)>,
6973    pub null_handling: Option<JsonNullHandling>,
6974    #[serde(default)]
6975    pub with_unique_keys: bool,
6976    #[serde(default)]
6977    pub returning_type: Option<DataType>,
6978    #[serde(default)]
6979    pub format_json: bool,
6980    #[serde(default)]
6981    pub encoding: Option<String>,
6982    /// For JSON_OBJECT(*) syntax
6983    #[serde(default)]
6984    pub star: bool,
6985}
6986
6987/// JSON null handling options
6988#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6989#[cfg_attr(feature = "bindings", derive(TS))]
6990pub enum JsonNullHandling {
6991    NullOnNull,
6992    AbsentOnNull,
6993}
6994
6995/// JSON_SET / JSON_INSERT function
6996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6997#[cfg_attr(feature = "bindings", derive(TS))]
6998pub struct JsonModifyFunc {
6999    pub this: Expression,
7000    pub path_values: Vec<(Expression, Expression)>,
7001}
7002
7003/// JSON_ARRAYAGG function
7004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7005#[cfg_attr(feature = "bindings", derive(TS))]
7006pub struct JsonArrayAggFunc {
7007    pub this: Expression,
7008    pub order_by: Option<Vec<Ordered>>,
7009    pub null_handling: Option<JsonNullHandling>,
7010    pub filter: Option<Expression>,
7011}
7012
7013/// JSON_OBJECTAGG function
7014#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7015#[cfg_attr(feature = "bindings", derive(TS))]
7016pub struct JsonObjectAggFunc {
7017    pub key: Expression,
7018    pub value: Expression,
7019    pub null_handling: Option<JsonNullHandling>,
7020    pub filter: Option<Expression>,
7021}
7022
7023// ============================================================================
7024// Type Casting Function types
7025// ============================================================================
7026
7027/// CONVERT function (SQL Server style)
7028#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7029#[cfg_attr(feature = "bindings", derive(TS))]
7030pub struct ConvertFunc {
7031    pub this: Expression,
7032    pub to: DataType,
7033    pub style: Option<Expression>,
7034}
7035
7036// ============================================================================
7037// Additional Expression types
7038// ============================================================================
7039
7040/// Lambda expression
7041#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7042#[cfg_attr(feature = "bindings", derive(TS))]
7043pub struct LambdaExpr {
7044    pub parameters: Vec<Identifier>,
7045    pub body: Expression,
7046    /// True if using DuckDB's LAMBDA x : expr syntax (vs x -> expr)
7047    #[serde(default)]
7048    pub colon: bool,
7049    /// Optional type annotations for parameters (Snowflake: a int -> a + 1)
7050    /// Maps parameter index to data type
7051    #[serde(default)]
7052    pub parameter_types: Vec<Option<DataType>>,
7053}
7054
7055/// Parameter (parameterized queries)
7056#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7057#[cfg_attr(feature = "bindings", derive(TS))]
7058pub struct Parameter {
7059    pub name: Option<String>,
7060    pub index: Option<u32>,
7061    pub style: ParameterStyle,
7062    /// Whether the name was quoted (e.g., @"x" vs @x)
7063    #[serde(default)]
7064    pub quoted: bool,
7065    /// Whether the name was string-quoted with single quotes (e.g., @'foo')
7066    #[serde(default)]
7067    pub string_quoted: bool,
7068    /// Optional secondary expression for ${kind:name} syntax (Hive hiveconf variables)
7069    #[serde(default)]
7070    pub expression: Option<String>,
7071}
7072
7073/// Parameter placeholder styles
7074#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7075#[cfg_attr(feature = "bindings", derive(TS))]
7076pub enum ParameterStyle {
7077    Question,     // ?
7078    Dollar,       // $1, $2
7079    DollarBrace,  // ${name} (Databricks, Hive template variables)
7080    Brace,        // {name} (Spark/Databricks widget/template variables)
7081    Colon,        // :name
7082    At,           // @name
7083    DoubleAt,     // @@name (system variables in MySQL/SQL Server)
7084    DoubleDollar, // $$name
7085    Percent,      // %s, %(name)s (PostgreSQL psycopg2 style)
7086}
7087
7088/// Placeholder expression
7089#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7090#[cfg_attr(feature = "bindings", derive(TS))]
7091pub struct Placeholder {
7092    pub index: Option<u32>,
7093}
7094
7095/// Named argument in function call: name => value or name := value
7096#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7097#[cfg_attr(feature = "bindings", derive(TS))]
7098pub struct NamedArgument {
7099    pub name: Identifier,
7100    pub value: Expression,
7101    /// The separator used: `=>`, `:=`, or `=`
7102    pub separator: NamedArgSeparator,
7103}
7104
7105/// Separator style for named arguments
7106#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7107#[cfg_attr(feature = "bindings", derive(TS))]
7108pub enum NamedArgSeparator {
7109    /// `=>` (standard SQL, Snowflake, BigQuery)
7110    DArrow,
7111    /// `:=` (Oracle, MySQL)
7112    ColonEq,
7113    /// `=` (simple equals, some dialects)
7114    Eq,
7115}
7116
7117/// TABLE ref or MODEL ref used as a function argument (BigQuery)
7118/// e.g., GAP_FILL(TABLE device_data, ...) or ML.PREDICT(MODEL mydataset.mymodel, ...)
7119#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7120#[cfg_attr(feature = "bindings", derive(TS))]
7121pub struct TableArgument {
7122    /// The keyword prefix: "TABLE" or "MODEL"
7123    pub prefix: String,
7124    /// The table/model reference expression
7125    pub this: Expression,
7126}
7127
7128/// SQL Comment preservation
7129#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7130#[cfg_attr(feature = "bindings", derive(TS))]
7131pub struct SqlComment {
7132    pub text: String,
7133    pub is_block: bool,
7134}
7135
7136// ============================================================================
7137// Additional Predicate types
7138// ============================================================================
7139
7140/// SIMILAR TO expression
7141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7142#[cfg_attr(feature = "bindings", derive(TS))]
7143pub struct SimilarToExpr {
7144    pub this: Expression,
7145    pub pattern: Expression,
7146    pub escape: Option<Expression>,
7147    pub not: bool,
7148}
7149
7150/// ANY / ALL quantified expression
7151#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7152#[cfg_attr(feature = "bindings", derive(TS))]
7153pub struct QuantifiedExpr {
7154    pub this: Expression,
7155    pub subquery: Expression,
7156    pub op: Option<QuantifiedOp>,
7157}
7158
7159/// Comparison operator for quantified expressions
7160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7161#[cfg_attr(feature = "bindings", derive(TS))]
7162pub enum QuantifiedOp {
7163    Eq,
7164    Neq,
7165    Lt,
7166    Lte,
7167    Gt,
7168    Gte,
7169}
7170
7171/// OVERLAPS expression
7172/// Supports two forms:
7173/// 1. Simple binary: a OVERLAPS b (this, expression are set)
7174/// 2. Full ANSI: (a, b) OVERLAPS (c, d) (left_start, left_end, right_start, right_end are set)
7175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7176#[cfg_attr(feature = "bindings", derive(TS))]
7177pub struct OverlapsExpr {
7178    /// Left operand for simple binary form
7179    #[serde(skip_serializing_if = "Option::is_none")]
7180    pub this: Option<Expression>,
7181    /// Right operand for simple binary form
7182    #[serde(skip_serializing_if = "Option::is_none")]
7183    pub expression: Option<Expression>,
7184    /// Left range start for full ANSI form
7185    #[serde(skip_serializing_if = "Option::is_none")]
7186    pub left_start: Option<Expression>,
7187    /// Left range end for full ANSI form
7188    #[serde(skip_serializing_if = "Option::is_none")]
7189    pub left_end: Option<Expression>,
7190    /// Right range start for full ANSI form
7191    #[serde(skip_serializing_if = "Option::is_none")]
7192    pub right_start: Option<Expression>,
7193    /// Right range end for full ANSI form
7194    #[serde(skip_serializing_if = "Option::is_none")]
7195    pub right_end: Option<Expression>,
7196}
7197
7198// ============================================================================
7199// Array/Struct/Map access
7200// ============================================================================
7201
7202/// Subscript access (array[index] or map[key])
7203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7204#[cfg_attr(feature = "bindings", derive(TS))]
7205pub struct Subscript {
7206    pub this: Expression,
7207    pub index: Expression,
7208}
7209
7210/// Dot access (struct.field)
7211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7212#[cfg_attr(feature = "bindings", derive(TS))]
7213pub struct DotAccess {
7214    pub this: Expression,
7215    pub field: Identifier,
7216}
7217
7218/// Method call (expr.method(args))
7219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7220#[cfg_attr(feature = "bindings", derive(TS))]
7221pub struct MethodCall {
7222    pub this: Expression,
7223    pub method: Identifier,
7224    pub args: Vec<Expression>,
7225}
7226
7227/// Array slice (array[start:end])
7228#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7229#[cfg_attr(feature = "bindings", derive(TS))]
7230pub struct ArraySlice {
7231    pub this: Expression,
7232    pub start: Option<Expression>,
7233    pub end: Option<Expression>,
7234}
7235
7236// ============================================================================
7237// DDL (Data Definition Language) Statements
7238// ============================================================================
7239
7240/// ON COMMIT behavior for temporary tables
7241#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7242#[cfg_attr(feature = "bindings", derive(TS))]
7243pub enum OnCommit {
7244    /// ON COMMIT PRESERVE ROWS
7245    PreserveRows,
7246    /// ON COMMIT DELETE ROWS
7247    DeleteRows,
7248}
7249
7250/// CREATE TABLE statement
7251#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7252#[cfg_attr(feature = "bindings", derive(TS))]
7253pub struct CreateTable {
7254    pub name: TableRef,
7255    /// ClickHouse: ON CLUSTER clause for distributed DDL
7256    #[serde(default, skip_serializing_if = "Option::is_none")]
7257    pub on_cluster: Option<OnCluster>,
7258    pub columns: Vec<ColumnDef>,
7259    pub constraints: Vec<TableConstraint>,
7260    pub if_not_exists: bool,
7261    pub temporary: bool,
7262    pub or_replace: bool,
7263    /// Table modifier: DYNAMIC, ICEBERG, EXTERNAL, HYBRID (Snowflake)
7264    #[serde(default, skip_serializing_if = "Option::is_none")]
7265    pub table_modifier: Option<String>,
7266    pub as_select: Option<Expression>,
7267    /// Whether the AS SELECT was wrapped in parentheses
7268    #[serde(default)]
7269    pub as_select_parenthesized: bool,
7270    /// ON COMMIT behavior for temporary tables
7271    #[serde(default)]
7272    pub on_commit: Option<OnCommit>,
7273    /// Clone source table (e.g., CREATE TABLE t CLONE source_table)
7274    #[serde(default)]
7275    pub clone_source: Option<TableRef>,
7276    /// Time travel AT/BEFORE clause for CLONE (e.g., AT(TIMESTAMP => '...'))
7277    #[serde(default, skip_serializing_if = "Option::is_none")]
7278    pub clone_at_clause: Option<Expression>,
7279    /// Whether this is a COPY operation (BigQuery) vs CLONE (Snowflake/Databricks)
7280    #[serde(default)]
7281    pub is_copy: bool,
7282    /// Whether this is a SHALLOW CLONE (Databricks/Delta Lake)
7283    #[serde(default)]
7284    pub shallow_clone: bool,
7285    /// Leading comments before the statement
7286    #[serde(default)]
7287    pub leading_comments: Vec<String>,
7288    /// WITH properties (e.g., WITH (FORMAT='parquet'))
7289    #[serde(default)]
7290    pub with_properties: Vec<(String, String)>,
7291    /// Teradata: table options after name before columns (comma-separated)
7292    #[serde(default)]
7293    pub teradata_post_name_options: Vec<String>,
7294    /// Teradata: WITH DATA (true) or WITH NO DATA (false) after AS SELECT
7295    #[serde(default)]
7296    pub with_data: Option<bool>,
7297    /// Teradata: AND STATISTICS (true) or AND NO STATISTICS (false)
7298    #[serde(default)]
7299    pub with_statistics: Option<bool>,
7300    /// Teradata: Index specifications (NO PRIMARY INDEX, UNIQUE PRIMARY INDEX, etc.)
7301    #[serde(default)]
7302    pub teradata_indexes: Vec<TeradataIndex>,
7303    /// WITH clause (CTEs) - for CREATE TABLE ... AS WITH ... SELECT ...
7304    #[serde(default)]
7305    pub with_cte: Option<With>,
7306    /// Table properties like DEFAULT COLLATE (BigQuery)
7307    #[serde(default)]
7308    pub properties: Vec<Expression>,
7309    /// PostgreSQL PARTITION OF property (e.g., CREATE TABLE t PARTITION OF parent ...)
7310    #[serde(default, skip_serializing_if = "Option::is_none")]
7311    pub partition_of: Option<Expression>,
7312    /// TSQL: WITH(SYSTEM_VERSIONING=ON(...)) after column definitions
7313    #[serde(default)]
7314    pub post_table_properties: Vec<Expression>,
7315    /// MySQL table options after column definitions (ENGINE=val, AUTO_INCREMENT=val, etc.)
7316    #[serde(default)]
7317    pub mysql_table_options: Vec<(String, String)>,
7318    /// PostgreSQL INHERITS clause: INHERITS (parent1, parent2, ...)
7319    #[serde(default, skip_serializing_if = "Vec::is_empty")]
7320    pub inherits: Vec<TableRef>,
7321    /// TSQL ON filegroup or ON filegroup (partition_column) clause
7322    #[serde(default, skip_serializing_if = "Option::is_none")]
7323    pub on_property: Option<OnProperty>,
7324    /// Snowflake: COPY GRANTS clause to copy privileges from replaced table
7325    #[serde(default)]
7326    pub copy_grants: bool,
7327    /// Snowflake: USING TEMPLATE expression for schema inference
7328    #[serde(default, skip_serializing_if = "Option::is_none")]
7329    pub using_template: Option<Box<Expression>>,
7330    /// StarRocks: ROLLUP (r1(col1, col2), r2(col1))
7331    #[serde(default, skip_serializing_if = "Option::is_none")]
7332    pub rollup: Option<RollupProperty>,
7333    /// ClickHouse: UUID 'xxx' clause after table name
7334    #[serde(default, skip_serializing_if = "Option::is_none")]
7335    pub uuid: Option<String>,
7336}
7337
7338/// Teradata index specification for CREATE TABLE
7339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7340#[cfg_attr(feature = "bindings", derive(TS))]
7341pub struct TeradataIndex {
7342    /// Index kind: NoPrimary, Primary, PrimaryAmp, Unique, UniquePrimary
7343    pub kind: TeradataIndexKind,
7344    /// Optional index name
7345    pub name: Option<String>,
7346    /// Optional column list
7347    pub columns: Vec<String>,
7348}
7349
7350/// Kind of Teradata index
7351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7352#[cfg_attr(feature = "bindings", derive(TS))]
7353pub enum TeradataIndexKind {
7354    /// NO PRIMARY INDEX
7355    NoPrimary,
7356    /// PRIMARY INDEX
7357    Primary,
7358    /// PRIMARY AMP INDEX
7359    PrimaryAmp,
7360    /// UNIQUE INDEX
7361    Unique,
7362    /// UNIQUE PRIMARY INDEX
7363    UniquePrimary,
7364    /// INDEX (secondary, non-primary)
7365    Secondary,
7366}
7367
7368impl CreateTable {
7369    pub fn new(name: impl Into<String>) -> Self {
7370        Self {
7371            name: TableRef::new(name),
7372            on_cluster: None,
7373            columns: Vec::new(),
7374            constraints: Vec::new(),
7375            if_not_exists: false,
7376            temporary: false,
7377            or_replace: false,
7378            table_modifier: None,
7379            as_select: None,
7380            as_select_parenthesized: false,
7381            on_commit: None,
7382            clone_source: None,
7383            clone_at_clause: None,
7384            shallow_clone: false,
7385            is_copy: false,
7386            leading_comments: Vec::new(),
7387            with_properties: Vec::new(),
7388            teradata_post_name_options: Vec::new(),
7389            with_data: None,
7390            with_statistics: None,
7391            teradata_indexes: Vec::new(),
7392            with_cte: None,
7393            properties: Vec::new(),
7394            partition_of: None,
7395            post_table_properties: Vec::new(),
7396            mysql_table_options: Vec::new(),
7397            inherits: Vec::new(),
7398            on_property: None,
7399            copy_grants: false,
7400            using_template: None,
7401            rollup: None,
7402            uuid: None,
7403        }
7404    }
7405}
7406
7407/// Sort order for PRIMARY KEY ASC/DESC
7408#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
7409#[cfg_attr(feature = "bindings", derive(TS))]
7410pub enum SortOrder {
7411    Asc,
7412    Desc,
7413}
7414
7415/// Type of column constraint for tracking order
7416#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7417#[cfg_attr(feature = "bindings", derive(TS))]
7418pub enum ConstraintType {
7419    NotNull,
7420    Null,
7421    PrimaryKey,
7422    Unique,
7423    Default,
7424    AutoIncrement,
7425    Collate,
7426    Comment,
7427    References,
7428    Check,
7429    GeneratedAsIdentity,
7430    /// Snowflake: TAG (key='value', ...)
7431    Tags,
7432    /// Computed/generated column
7433    ComputedColumn,
7434    /// TSQL temporal: GENERATED ALWAYS AS ROW START|END
7435    GeneratedAsRow,
7436    /// MySQL: ON UPDATE expression
7437    OnUpdate,
7438    /// PATH constraint for XMLTABLE/JSON_TABLE columns
7439    Path,
7440    /// Redshift: ENCODE encoding_type
7441    Encode,
7442}
7443
7444/// Column definition in CREATE TABLE
7445#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7446#[cfg_attr(feature = "bindings", derive(TS))]
7447pub struct ColumnDef {
7448    pub name: Identifier,
7449    pub data_type: DataType,
7450    pub nullable: Option<bool>,
7451    pub default: Option<Expression>,
7452    pub primary_key: bool,
7453    /// Sort order for PRIMARY KEY (ASC/DESC)
7454    #[serde(default)]
7455    pub primary_key_order: Option<SortOrder>,
7456    pub unique: bool,
7457    /// PostgreSQL 15+: UNIQUE NULLS NOT DISTINCT
7458    #[serde(default)]
7459    pub unique_nulls_not_distinct: bool,
7460    pub auto_increment: bool,
7461    pub comment: Option<String>,
7462    pub constraints: Vec<ColumnConstraint>,
7463    /// Track original order of constraints for accurate regeneration
7464    #[serde(default)]
7465    pub constraint_order: Vec<ConstraintType>,
7466    /// Teradata: FORMAT 'pattern'
7467    #[serde(default)]
7468    pub format: Option<String>,
7469    /// Teradata: TITLE 'title'
7470    #[serde(default)]
7471    pub title: Option<String>,
7472    /// Teradata: INLINE LENGTH n
7473    #[serde(default)]
7474    pub inline_length: Option<u64>,
7475    /// Teradata: COMPRESS or COMPRESS (values) or COMPRESS 'value'
7476    #[serde(default)]
7477    pub compress: Option<Vec<Expression>>,
7478    /// Teradata: CHARACTER SET name
7479    #[serde(default)]
7480    pub character_set: Option<String>,
7481    /// Teradata: UPPERCASE
7482    #[serde(default)]
7483    pub uppercase: bool,
7484    /// Teradata: CASESPECIFIC / NOT CASESPECIFIC (None = not specified, Some(true) = CASESPECIFIC, Some(false) = NOT CASESPECIFIC)
7485    #[serde(default)]
7486    pub casespecific: Option<bool>,
7487    /// Snowflake: AUTOINCREMENT START value
7488    #[serde(default)]
7489    pub auto_increment_start: Option<Box<Expression>>,
7490    /// Snowflake: AUTOINCREMENT INCREMENT value
7491    #[serde(default)]
7492    pub auto_increment_increment: Option<Box<Expression>>,
7493    /// Snowflake: AUTOINCREMENT ORDER/NOORDER (true = ORDER, false = NOORDER, None = not specified)
7494    #[serde(default)]
7495    pub auto_increment_order: Option<bool>,
7496    /// MySQL: UNSIGNED modifier
7497    #[serde(default)]
7498    pub unsigned: bool,
7499    /// MySQL: ZEROFILL modifier
7500    #[serde(default)]
7501    pub zerofill: bool,
7502    /// MySQL: ON UPDATE expression (e.g., ON UPDATE CURRENT_TIMESTAMP)
7503    #[serde(default, skip_serializing_if = "Option::is_none")]
7504    pub on_update: Option<Expression>,
7505    /// Named constraint for UNIQUE (e.g., CONSTRAINT must_be_different UNIQUE)
7506    #[serde(default, skip_serializing_if = "Option::is_none")]
7507    pub unique_constraint_name: Option<String>,
7508    /// Named constraint for NOT NULL (e.g., CONSTRAINT present NOT NULL)
7509    #[serde(default, skip_serializing_if = "Option::is_none")]
7510    pub not_null_constraint_name: Option<String>,
7511    /// Named constraint for PRIMARY KEY (e.g., CONSTRAINT pk_name PRIMARY KEY)
7512    #[serde(default, skip_serializing_if = "Option::is_none")]
7513    pub primary_key_constraint_name: Option<String>,
7514    /// Named constraint for CHECK (e.g., CONSTRAINT chk_name CHECK(...))
7515    #[serde(default, skip_serializing_if = "Option::is_none")]
7516    pub check_constraint_name: Option<String>,
7517    /// BigQuery: OPTIONS (key=value, ...) on column
7518    #[serde(default, skip_serializing_if = "Vec::is_empty")]
7519    pub options: Vec<Expression>,
7520    /// SQLite: Column definition without explicit type
7521    #[serde(default)]
7522    pub no_type: bool,
7523    /// Redshift: ENCODE encoding_type (e.g., ZSTD, DELTA, LZO, etc.)
7524    #[serde(default, skip_serializing_if = "Option::is_none")]
7525    pub encoding: Option<String>,
7526    /// ClickHouse: CODEC(LZ4HC(9), ZSTD, DELTA)
7527    #[serde(default, skip_serializing_if = "Option::is_none")]
7528    pub codec: Option<String>,
7529    /// ClickHouse: EPHEMERAL [expr] modifier
7530    #[serde(default, skip_serializing_if = "Option::is_none")]
7531    pub ephemeral: Option<Option<Box<Expression>>>,
7532    /// ClickHouse: MATERIALIZED expr modifier
7533    #[serde(default, skip_serializing_if = "Option::is_none")]
7534    pub materialized_expr: Option<Box<Expression>>,
7535    /// ClickHouse: ALIAS expr modifier
7536    #[serde(default, skip_serializing_if = "Option::is_none")]
7537    pub alias_expr: Option<Box<Expression>>,
7538    /// ClickHouse: TTL expr modifier on columns
7539    #[serde(default, skip_serializing_if = "Option::is_none")]
7540    pub ttl_expr: Option<Box<Expression>>,
7541    /// TSQL: NOT FOR REPLICATION
7542    #[serde(default)]
7543    pub not_for_replication: bool,
7544}
7545
7546impl ColumnDef {
7547    pub fn new(name: impl Into<String>, data_type: DataType) -> Self {
7548        Self {
7549            name: Identifier::new(name),
7550            data_type,
7551            nullable: None,
7552            default: None,
7553            primary_key: false,
7554            primary_key_order: None,
7555            unique: false,
7556            unique_nulls_not_distinct: false,
7557            auto_increment: false,
7558            comment: None,
7559            constraints: Vec::new(),
7560            constraint_order: Vec::new(),
7561            format: None,
7562            title: None,
7563            inline_length: None,
7564            compress: None,
7565            character_set: None,
7566            uppercase: false,
7567            casespecific: None,
7568            auto_increment_start: None,
7569            auto_increment_increment: None,
7570            auto_increment_order: None,
7571            unsigned: false,
7572            zerofill: false,
7573            on_update: None,
7574            unique_constraint_name: None,
7575            not_null_constraint_name: None,
7576            primary_key_constraint_name: None,
7577            check_constraint_name: None,
7578            options: Vec::new(),
7579            no_type: false,
7580            encoding: None,
7581            codec: None,
7582            ephemeral: None,
7583            materialized_expr: None,
7584            alias_expr: None,
7585            ttl_expr: None,
7586            not_for_replication: false,
7587        }
7588    }
7589}
7590
7591/// Column-level constraint
7592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7593#[cfg_attr(feature = "bindings", derive(TS))]
7594pub enum ColumnConstraint {
7595    NotNull,
7596    Null,
7597    Unique,
7598    PrimaryKey,
7599    Default(Expression),
7600    Check(Expression),
7601    References(ForeignKeyRef),
7602    GeneratedAsIdentity(GeneratedAsIdentity),
7603    Collate(Identifier),
7604    Comment(String),
7605    /// Snowflake: TAG (key='value', ...)
7606    Tags(Tags),
7607    /// Computed/generated column: GENERATED ALWAYS AS (expr) STORED|VIRTUAL (MySQL/PostgreSQL)
7608    /// or AS (expr) PERSISTED [NOT NULL] (TSQL)
7609    ComputedColumn(ComputedColumn),
7610    /// TSQL temporal: GENERATED ALWAYS AS ROW START|END [HIDDEN]
7611    GeneratedAsRow(GeneratedAsRow),
7612    /// PATH constraint for XMLTABLE/JSON_TABLE columns: PATH 'xpath'
7613    Path(Expression),
7614}
7615
7616/// Computed/generated column constraint
7617#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7618#[cfg_attr(feature = "bindings", derive(TS))]
7619pub struct ComputedColumn {
7620    /// The expression that computes the column value
7621    pub expression: Box<Expression>,
7622    /// PERSISTED (TSQL) or STORED (MySQL/PostgreSQL) = true; VIRTUAL = false; None = not specified
7623    #[serde(default)]
7624    pub persisted: bool,
7625    /// NOT NULL (TSQL computed columns)
7626    #[serde(default)]
7627    pub not_null: bool,
7628    /// The persistence keyword used: "STORED", "VIRTUAL", or "PERSISTED"
7629    /// When None, defaults to dialect-appropriate output
7630    #[serde(default)]
7631    pub persistence_kind: Option<String>,
7632    /// Optional data type for SingleStore: AS (expr) PERSISTED TYPE NOT NULL
7633    #[serde(default, skip_serializing_if = "Option::is_none")]
7634    pub data_type: Option<DataType>,
7635}
7636
7637/// TSQL temporal column constraint: GENERATED ALWAYS AS ROW START|END [HIDDEN]
7638#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7639#[cfg_attr(feature = "bindings", derive(TS))]
7640pub struct GeneratedAsRow {
7641    /// true = ROW START, false = ROW END
7642    pub start: bool,
7643    /// HIDDEN modifier
7644    #[serde(default)]
7645    pub hidden: bool,
7646}
7647
7648/// Generated identity column constraint
7649#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7650#[cfg_attr(feature = "bindings", derive(TS))]
7651pub struct GeneratedAsIdentity {
7652    /// True for ALWAYS, False for BY DEFAULT
7653    pub always: bool,
7654    /// ON NULL (only valid with BY DEFAULT)
7655    pub on_null: bool,
7656    /// START WITH value
7657    pub start: Option<Box<Expression>>,
7658    /// INCREMENT BY value
7659    pub increment: Option<Box<Expression>>,
7660    /// MINVALUE
7661    pub minvalue: Option<Box<Expression>>,
7662    /// MAXVALUE
7663    pub maxvalue: Option<Box<Expression>>,
7664    /// CYCLE option - Some(true) = CYCLE, Some(false) = NO CYCLE, None = not specified
7665    pub cycle: Option<bool>,
7666}
7667
7668/// Constraint modifiers (shared between table-level constraints)
7669#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
7670#[cfg_attr(feature = "bindings", derive(TS))]
7671pub struct ConstraintModifiers {
7672    /// ENFORCED / NOT ENFORCED
7673    pub enforced: Option<bool>,
7674    /// DEFERRABLE / NOT DEFERRABLE
7675    pub deferrable: Option<bool>,
7676    /// INITIALLY DEFERRED / INITIALLY IMMEDIATE
7677    pub initially_deferred: Option<bool>,
7678    /// NORELY (Oracle)
7679    pub norely: bool,
7680    /// RELY (Oracle)
7681    pub rely: bool,
7682    /// USING index type (MySQL): BTREE or HASH
7683    #[serde(default)]
7684    pub using: Option<String>,
7685    /// True if USING appeared before columns (MySQL: INDEX USING BTREE (col) vs INDEX (col) USING BTREE)
7686    #[serde(default)]
7687    pub using_before_columns: bool,
7688    /// MySQL index COMMENT 'text'
7689    #[serde(default, skip_serializing_if = "Option::is_none")]
7690    pub comment: Option<String>,
7691    /// MySQL index VISIBLE/INVISIBLE
7692    #[serde(default, skip_serializing_if = "Option::is_none")]
7693    pub visible: Option<bool>,
7694    /// MySQL ENGINE_ATTRIBUTE = 'value'
7695    #[serde(default, skip_serializing_if = "Option::is_none")]
7696    pub engine_attribute: Option<String>,
7697    /// MySQL WITH PARSER name
7698    #[serde(default, skip_serializing_if = "Option::is_none")]
7699    pub with_parser: Option<String>,
7700    /// PostgreSQL NOT VALID (constraint is not validated against existing data)
7701    #[serde(default)]
7702    pub not_valid: bool,
7703    /// TSQL CLUSTERED/NONCLUSTERED modifier
7704    #[serde(default, skip_serializing_if = "Option::is_none")]
7705    pub clustered: Option<String>,
7706    /// SQLite ON CONFLICT clause: ROLLBACK, ABORT, FAIL, IGNORE, or REPLACE
7707    #[serde(default, skip_serializing_if = "Option::is_none")]
7708    pub on_conflict: Option<String>,
7709    /// TSQL WITH options (e.g., PAD_INDEX=ON, STATISTICS_NORECOMPUTE=OFF)
7710    #[serde(default, skip_serializing_if = "Vec::is_empty")]
7711    pub with_options: Vec<(String, String)>,
7712    /// TSQL ON filegroup (e.g., ON [INDEX], ON [PRIMARY])
7713    #[serde(default, skip_serializing_if = "Option::is_none")]
7714    pub on_filegroup: Option<Identifier>,
7715}
7716
7717/// Table-level constraint
7718#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7719#[cfg_attr(feature = "bindings", derive(TS))]
7720pub enum TableConstraint {
7721    PrimaryKey {
7722        name: Option<Identifier>,
7723        columns: Vec<Identifier>,
7724        /// INCLUDE (columns) - non-key columns included in the index (PostgreSQL)
7725        #[serde(default)]
7726        include_columns: Vec<Identifier>,
7727        #[serde(default)]
7728        modifiers: ConstraintModifiers,
7729        /// Whether the CONSTRAINT keyword was used (vs MySQL's `PRIMARY KEY name (cols)` syntax)
7730        #[serde(default)]
7731        has_constraint_keyword: bool,
7732    },
7733    Unique {
7734        name: Option<Identifier>,
7735        columns: Vec<Identifier>,
7736        /// Whether columns are parenthesized (false for UNIQUE idx_name without parens)
7737        #[serde(default)]
7738        columns_parenthesized: bool,
7739        #[serde(default)]
7740        modifiers: ConstraintModifiers,
7741        /// Whether the CONSTRAINT keyword was used (vs MySQL's `UNIQUE name (cols)` syntax)
7742        #[serde(default)]
7743        has_constraint_keyword: bool,
7744        /// PostgreSQL 15+: NULLS NOT DISTINCT
7745        #[serde(default)]
7746        nulls_not_distinct: bool,
7747    },
7748    ForeignKey {
7749        name: Option<Identifier>,
7750        columns: Vec<Identifier>,
7751        #[serde(default)]
7752        references: Option<ForeignKeyRef>,
7753        /// ON DELETE action when REFERENCES is absent
7754        #[serde(default)]
7755        on_delete: Option<ReferentialAction>,
7756        /// ON UPDATE action when REFERENCES is absent
7757        #[serde(default)]
7758        on_update: Option<ReferentialAction>,
7759        #[serde(default)]
7760        modifiers: ConstraintModifiers,
7761    },
7762    Check {
7763        name: Option<Identifier>,
7764        expression: Expression,
7765        #[serde(default)]
7766        modifiers: ConstraintModifiers,
7767    },
7768    /// ClickHouse ASSUME constraint (query optimization assumption)
7769    Assume {
7770        name: Option<Identifier>,
7771        expression: Expression,
7772    },
7773    /// INDEX / KEY constraint (MySQL)
7774    Index {
7775        name: Option<Identifier>,
7776        columns: Vec<Identifier>,
7777        /// Index kind: UNIQUE, FULLTEXT, SPATIAL, etc.
7778        #[serde(default)]
7779        kind: Option<String>,
7780        #[serde(default)]
7781        modifiers: ConstraintModifiers,
7782        /// True if KEY keyword was used instead of INDEX
7783        #[serde(default)]
7784        use_key_keyword: bool,
7785        /// ClickHouse: indexed expression (instead of columns)
7786        #[serde(default, skip_serializing_if = "Option::is_none")]
7787        expression: Option<Box<Expression>>,
7788        /// ClickHouse: TYPE type_func(args)
7789        #[serde(default, skip_serializing_if = "Option::is_none")]
7790        index_type: Option<Box<Expression>>,
7791        /// ClickHouse: GRANULARITY n
7792        #[serde(default, skip_serializing_if = "Option::is_none")]
7793        granularity: Option<Box<Expression>>,
7794    },
7795    /// ClickHouse PROJECTION definition
7796    Projection {
7797        name: Identifier,
7798        expression: Expression,
7799    },
7800    /// PostgreSQL LIKE clause: LIKE source_table [INCLUDING|EXCLUDING options]
7801    Like {
7802        source: TableRef,
7803        /// Options as (INCLUDING|EXCLUDING, property) pairs
7804        options: Vec<(LikeOptionAction, String)>,
7805    },
7806    /// TSQL PERIOD FOR SYSTEM_TIME (start_col, end_col)
7807    PeriodForSystemTime {
7808        start_col: Identifier,
7809        end_col: Identifier,
7810    },
7811    /// PostgreSQL EXCLUDE constraint
7812    /// EXCLUDE [USING method] (element WITH operator, ...) [INCLUDE (cols)] [WHERE (expr)] [WITH (params)]
7813    Exclude {
7814        name: Option<Identifier>,
7815        /// Index access method (gist, btree, etc.)
7816        #[serde(default)]
7817        using: Option<String>,
7818        /// Elements: (expression, operator) pairs
7819        elements: Vec<ExcludeElement>,
7820        /// INCLUDE columns
7821        #[serde(default)]
7822        include_columns: Vec<Identifier>,
7823        /// WHERE predicate
7824        #[serde(default)]
7825        where_clause: Option<Box<Expression>>,
7826        /// WITH (storage_parameters)
7827        #[serde(default)]
7828        with_params: Vec<(String, String)>,
7829        /// USING INDEX TABLESPACE tablespace_name
7830        #[serde(default)]
7831        using_index_tablespace: Option<String>,
7832        #[serde(default)]
7833        modifiers: ConstraintModifiers,
7834    },
7835    /// Snowflake TAG clause: TAG (key='value', key2='value2')
7836    Tags(Tags),
7837    /// PostgreSQL table-level INITIALLY DEFERRED/INITIALLY IMMEDIATE
7838    /// This is a standalone clause at the end of the CREATE TABLE that sets the default
7839    /// for all deferrable constraints in the table
7840    InitiallyDeferred {
7841        /// true = INITIALLY DEFERRED, false = INITIALLY IMMEDIATE
7842        deferred: bool,
7843    },
7844}
7845
7846/// Element in an EXCLUDE constraint: expression WITH operator
7847#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7848#[cfg_attr(feature = "bindings", derive(TS))]
7849pub struct ExcludeElement {
7850    /// The column expression (may include operator class, ordering, nulls)
7851    pub expression: String,
7852    /// The operator (e.g., &&, =)
7853    pub operator: String,
7854}
7855
7856/// Action for LIKE clause options
7857#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7858#[cfg_attr(feature = "bindings", derive(TS))]
7859pub enum LikeOptionAction {
7860    Including,
7861    Excluding,
7862}
7863
7864/// MATCH type for foreign keys
7865#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7866#[cfg_attr(feature = "bindings", derive(TS))]
7867pub enum MatchType {
7868    Full,
7869    Partial,
7870    Simple,
7871}
7872
7873/// Foreign key reference
7874#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7875#[cfg_attr(feature = "bindings", derive(TS))]
7876pub struct ForeignKeyRef {
7877    pub table: TableRef,
7878    pub columns: Vec<Identifier>,
7879    pub on_delete: Option<ReferentialAction>,
7880    pub on_update: Option<ReferentialAction>,
7881    /// True if ON UPDATE appears before ON DELETE in the original SQL
7882    #[serde(default)]
7883    pub on_update_first: bool,
7884    /// MATCH clause (FULL, PARTIAL, SIMPLE)
7885    #[serde(default)]
7886    pub match_type: Option<MatchType>,
7887    /// True if MATCH appears after ON DELETE/ON UPDATE clauses
7888    #[serde(default)]
7889    pub match_after_actions: bool,
7890    /// CONSTRAINT name (e.g., CONSTRAINT fk_name REFERENCES ...)
7891    #[serde(default)]
7892    pub constraint_name: Option<String>,
7893    /// DEFERRABLE / NOT DEFERRABLE
7894    #[serde(default)]
7895    pub deferrable: Option<bool>,
7896    /// Snowflake: FOREIGN KEY REFERENCES (includes FOREIGN KEY keywords before REFERENCES)
7897    #[serde(default)]
7898    pub has_foreign_key_keywords: bool,
7899}
7900
7901/// Referential action for foreign keys
7902#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7903#[cfg_attr(feature = "bindings", derive(TS))]
7904pub enum ReferentialAction {
7905    Cascade,
7906    SetNull,
7907    SetDefault,
7908    Restrict,
7909    NoAction,
7910}
7911
7912/// DROP TABLE statement
7913#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7914#[cfg_attr(feature = "bindings", derive(TS))]
7915pub struct DropTable {
7916    pub names: Vec<TableRef>,
7917    pub if_exists: bool,
7918    pub cascade: bool,
7919    /// Oracle: CASCADE CONSTRAINTS
7920    #[serde(default)]
7921    pub cascade_constraints: bool,
7922    /// Oracle: PURGE
7923    #[serde(default)]
7924    pub purge: bool,
7925    /// Comments that appear before the DROP keyword (e.g., leading line comments)
7926    #[serde(default)]
7927    pub leading_comments: Vec<String>,
7928    /// TSQL: OBJECT_ID arguments for reconstructing IF OBJECT_ID(...) IS NOT NULL pattern
7929    /// When set, TSQL generator outputs IF NOT OBJECT_ID(...) IS NULL BEGIN DROP TABLE ...; END
7930    #[serde(default, skip_serializing_if = "Option::is_none")]
7931    pub object_id_args: Option<String>,
7932    /// ClickHouse: SYNC modifier
7933    #[serde(default)]
7934    pub sync: bool,
7935    /// Snowflake: DROP ICEBERG TABLE
7936    #[serde(default)]
7937    pub iceberg: bool,
7938    /// RESTRICT modifier (opposite of CASCADE)
7939    #[serde(default)]
7940    pub restrict: bool,
7941}
7942
7943impl DropTable {
7944    pub fn new(name: impl Into<String>) -> Self {
7945        Self {
7946            names: vec![TableRef::new(name)],
7947            if_exists: false,
7948            cascade: false,
7949            cascade_constraints: false,
7950            purge: false,
7951            leading_comments: Vec::new(),
7952            object_id_args: None,
7953            sync: false,
7954            iceberg: false,
7955            restrict: false,
7956        }
7957    }
7958}
7959
7960/// ALTER TABLE statement
7961#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7962#[cfg_attr(feature = "bindings", derive(TS))]
7963pub struct AlterTable {
7964    pub name: TableRef,
7965    pub actions: Vec<AlterTableAction>,
7966    /// IF EXISTS clause
7967    #[serde(default)]
7968    pub if_exists: bool,
7969    /// MySQL: ALGORITHM=INPLACE|COPY|DEFAULT|INSTANT
7970    #[serde(default, skip_serializing_if = "Option::is_none")]
7971    pub algorithm: Option<String>,
7972    /// MySQL: LOCK=NONE|SHARED|DEFAULT|EXCLUSIVE
7973    #[serde(default, skip_serializing_if = "Option::is_none")]
7974    pub lock: Option<String>,
7975    /// TSQL: WITH CHECK / WITH NOCHECK modifier before ADD CONSTRAINT
7976    #[serde(default, skip_serializing_if = "Option::is_none")]
7977    pub with_check: Option<String>,
7978    /// Hive: PARTITION clause before actions (e.g., ALTER TABLE x PARTITION(y=z) ADD COLUMN ...)
7979    #[serde(default, skip_serializing_if = "Option::is_none")]
7980    pub partition: Option<Vec<(Identifier, Expression)>>,
7981    /// ClickHouse: ON CLUSTER clause for distributed DDL
7982    #[serde(default, skip_serializing_if = "Option::is_none")]
7983    pub on_cluster: Option<OnCluster>,
7984    /// Snowflake: ALTER ICEBERG TABLE
7985    #[serde(default, skip_serializing_if = "Option::is_none")]
7986    pub table_modifier: Option<String>,
7987}
7988
7989impl AlterTable {
7990    pub fn new(name: impl Into<String>) -> Self {
7991        Self {
7992            name: TableRef::new(name),
7993            actions: Vec::new(),
7994            if_exists: false,
7995            algorithm: None,
7996            lock: None,
7997            with_check: None,
7998            partition: None,
7999            on_cluster: None,
8000            table_modifier: None,
8001        }
8002    }
8003}
8004
8005/// Column position for ADD COLUMN (MySQL/MariaDB)
8006#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8007#[cfg_attr(feature = "bindings", derive(TS))]
8008pub enum ColumnPosition {
8009    First,
8010    After(Identifier),
8011}
8012
8013/// Actions for ALTER TABLE
8014#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8015#[cfg_attr(feature = "bindings", derive(TS))]
8016pub enum AlterTableAction {
8017    AddColumn {
8018        column: ColumnDef,
8019        if_not_exists: bool,
8020        position: Option<ColumnPosition>,
8021    },
8022    DropColumn {
8023        name: Identifier,
8024        if_exists: bool,
8025        cascade: bool,
8026    },
8027    RenameColumn {
8028        old_name: Identifier,
8029        new_name: Identifier,
8030        if_exists: bool,
8031    },
8032    AlterColumn {
8033        name: Identifier,
8034        action: AlterColumnAction,
8035        /// Whether this was parsed from MODIFY COLUMN syntax (MySQL)
8036        #[serde(default)]
8037        use_modify_keyword: bool,
8038    },
8039    RenameTable(TableRef),
8040    AddConstraint(TableConstraint),
8041    DropConstraint {
8042        name: Identifier,
8043        if_exists: bool,
8044    },
8045    /// DROP FOREIGN KEY action (Oracle/MySQL): ALTER TABLE t DROP FOREIGN KEY fk_name
8046    DropForeignKey {
8047        name: Identifier,
8048    },
8049    /// DROP PARTITION action (Hive/BigQuery)
8050    DropPartition {
8051        /// List of partitions to drop (each partition is a list of key=value pairs)
8052        partitions: Vec<Vec<(Identifier, Expression)>>,
8053        if_exists: bool,
8054    },
8055    /// ADD PARTITION action (Hive/Spark)
8056    AddPartition {
8057        /// The partition expression
8058        partition: Expression,
8059        if_not_exists: bool,
8060        location: Option<Expression>,
8061    },
8062    /// DELETE action (BigQuery): ALTER TABLE t DELETE WHERE condition
8063    Delete {
8064        where_clause: Expression,
8065    },
8066    /// SWAP WITH action (Snowflake): ALTER TABLE a SWAP WITH b
8067    SwapWith(TableRef),
8068    /// SET property action (Snowflake): ALTER TABLE t SET property=value
8069    SetProperty {
8070        properties: Vec<(String, Expression)>,
8071    },
8072    /// UNSET property action (Snowflake): ALTER TABLE t UNSET property
8073    UnsetProperty {
8074        properties: Vec<String>,
8075    },
8076    /// CLUSTER BY action (Snowflake): ALTER TABLE t CLUSTER BY (col1, col2)
8077    ClusterBy {
8078        expressions: Vec<Expression>,
8079    },
8080    /// SET TAG action (Snowflake): ALTER TABLE t SET TAG key='value'
8081    SetTag {
8082        expressions: Vec<(String, Expression)>,
8083    },
8084    /// UNSET TAG action (Snowflake): ALTER TABLE t UNSET TAG key1, key2
8085    UnsetTag {
8086        names: Vec<String>,
8087    },
8088    /// SET with parenthesized options (TSQL): ALTER TABLE t SET (SYSTEM_VERSIONING=ON, ...)
8089    SetOptions {
8090        expressions: Vec<Expression>,
8091    },
8092    /// ALTER INDEX action (MySQL): ALTER TABLE t ALTER INDEX i VISIBLE/INVISIBLE
8093    AlterIndex {
8094        name: Identifier,
8095        visible: bool,
8096    },
8097    /// PostgreSQL: ALTER TABLE t SET LOGGED/UNLOGGED/WITHOUT CLUSTER/WITHOUT OIDS/ACCESS METHOD/TABLESPACE
8098    SetAttribute {
8099        attribute: String,
8100    },
8101    /// Snowflake: ALTER TABLE t SET STAGE_FILE_FORMAT = (options)
8102    SetStageFileFormat {
8103        options: Option<Expression>,
8104    },
8105    /// Snowflake: ALTER TABLE t SET STAGE_COPY_OPTIONS = (options)
8106    SetStageCopyOptions {
8107        options: Option<Expression>,
8108    },
8109    /// Hive/Spark: ADD COLUMNS (col1 TYPE, col2 TYPE) [CASCADE]
8110    AddColumns {
8111        columns: Vec<ColumnDef>,
8112        cascade: bool,
8113    },
8114    /// Spark/Databricks: DROP COLUMNS (col1, col2, ...)
8115    DropColumns {
8116        names: Vec<Identifier>,
8117    },
8118    /// Hive/MySQL/SingleStore: CHANGE [COLUMN] old_name new_name [data_type] [COMMENT 'comment']
8119    /// In SingleStore, data_type can be omitted for simple column renames
8120    ChangeColumn {
8121        old_name: Identifier,
8122        new_name: Identifier,
8123        #[serde(default, skip_serializing_if = "Option::is_none")]
8124        data_type: Option<DataType>,
8125        comment: Option<String>,
8126        #[serde(default)]
8127        cascade: bool,
8128    },
8129    /// Redshift: ALTER TABLE t ALTER SORTKEY AUTO|NONE|(col1, col2)
8130    /// Also: ALTER TABLE t ALTER COMPOUND SORTKEY (col1, col2)
8131    AlterSortKey {
8132        /// AUTO or NONE keyword
8133        this: Option<String>,
8134        /// Column list for (col1, col2) syntax
8135        expressions: Vec<Expression>,
8136        /// Whether COMPOUND keyword was present
8137        compound: bool,
8138    },
8139    /// Redshift: ALTER TABLE t ALTER DISTSTYLE ALL|EVEN|AUTO|KEY
8140    /// Also: ALTER TABLE t ALTER DISTSTYLE KEY DISTKEY col
8141    /// Also: ALTER TABLE t ALTER DISTKEY col (shorthand for DISTSTYLE KEY DISTKEY col)
8142    AlterDistStyle {
8143        /// Distribution style: ALL, EVEN, AUTO, or KEY
8144        style: String,
8145        /// DISTKEY column (only when style is KEY)
8146        distkey: Option<Identifier>,
8147    },
8148    /// Redshift: ALTER TABLE t SET TABLE PROPERTIES ('a' = '5', 'b' = 'c')
8149    SetTableProperties {
8150        properties: Vec<(Expression, Expression)>,
8151    },
8152    /// Redshift: ALTER TABLE t SET LOCATION 's3://bucket/folder/'
8153    SetLocation {
8154        location: String,
8155    },
8156    /// Redshift: ALTER TABLE t SET FILE FORMAT AVRO
8157    SetFileFormat {
8158        format: String,
8159    },
8160    /// ClickHouse: ALTER TABLE t REPLACE PARTITION expr FROM source_table
8161    ReplacePartition {
8162        partition: Expression,
8163        source: Option<Box<Expression>>,
8164    },
8165    /// Raw SQL for dialect-specific ALTER TABLE actions (e.g., ClickHouse UPDATE/DELETE/DETACH/etc.)
8166    Raw {
8167        sql: String,
8168    },
8169}
8170
8171/// Actions for ALTER COLUMN
8172#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8173#[cfg_attr(feature = "bindings", derive(TS))]
8174pub enum AlterColumnAction {
8175    SetDataType {
8176        data_type: DataType,
8177        /// USING expression for type conversion (PostgreSQL)
8178        using: Option<Expression>,
8179        /// COLLATE clause (TSQL: ALTER COLUMN col TYPE COLLATE collation_name)
8180        #[serde(default, skip_serializing_if = "Option::is_none")]
8181        collate: Option<String>,
8182    },
8183    SetDefault(Expression),
8184    DropDefault,
8185    SetNotNull,
8186    DropNotNull,
8187    /// Set column comment
8188    Comment(String),
8189    /// MySQL: SET VISIBLE
8190    SetVisible,
8191    /// MySQL: SET INVISIBLE
8192    SetInvisible,
8193}
8194
8195/// CREATE INDEX statement
8196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8197#[cfg_attr(feature = "bindings", derive(TS))]
8198pub struct CreateIndex {
8199    pub name: Identifier,
8200    pub table: TableRef,
8201    pub columns: Vec<IndexColumn>,
8202    pub unique: bool,
8203    pub if_not_exists: bool,
8204    pub using: Option<String>,
8205    /// TSQL CLUSTERED/NONCLUSTERED modifier
8206    #[serde(default)]
8207    pub clustered: Option<String>,
8208    /// PostgreSQL CONCURRENTLY modifier
8209    #[serde(default)]
8210    pub concurrently: bool,
8211    /// PostgreSQL WHERE clause for partial indexes
8212    #[serde(default)]
8213    pub where_clause: Option<Box<Expression>>,
8214    /// PostgreSQL INCLUDE columns
8215    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8216    pub include_columns: Vec<Identifier>,
8217    /// TSQL WITH options (e.g., allow_page_locks=on)
8218    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8219    pub with_options: Vec<(String, String)>,
8220    /// TSQL ON filegroup or partition scheme (e.g., ON PRIMARY, ON X([y]))
8221    #[serde(default)]
8222    pub on_filegroup: Option<String>,
8223}
8224
8225impl CreateIndex {
8226    pub fn new(name: impl Into<String>, table: impl Into<String>) -> Self {
8227        Self {
8228            name: Identifier::new(name),
8229            table: TableRef::new(table),
8230            columns: Vec::new(),
8231            unique: false,
8232            if_not_exists: false,
8233            using: None,
8234            clustered: None,
8235            concurrently: false,
8236            where_clause: None,
8237            include_columns: Vec::new(),
8238            with_options: Vec::new(),
8239            on_filegroup: None,
8240        }
8241    }
8242}
8243
8244/// Index column specification
8245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8246#[cfg_attr(feature = "bindings", derive(TS))]
8247pub struct IndexColumn {
8248    pub column: Identifier,
8249    pub desc: bool,
8250    /// Explicit ASC keyword was present
8251    #[serde(default)]
8252    pub asc: bool,
8253    pub nulls_first: Option<bool>,
8254    /// PostgreSQL operator class (e.g., varchar_pattern_ops, public.gin_trgm_ops)
8255    #[serde(default, skip_serializing_if = "Option::is_none")]
8256    pub opclass: Option<String>,
8257}
8258
8259/// DROP INDEX statement
8260#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8261#[cfg_attr(feature = "bindings", derive(TS))]
8262pub struct DropIndex {
8263    pub name: Identifier,
8264    pub table: Option<TableRef>,
8265    pub if_exists: bool,
8266    /// PostgreSQL CONCURRENTLY modifier
8267    #[serde(default)]
8268    pub concurrently: bool,
8269}
8270
8271impl DropIndex {
8272    pub fn new(name: impl Into<String>) -> Self {
8273        Self {
8274            name: Identifier::new(name),
8275            table: None,
8276            if_exists: false,
8277            concurrently: false,
8278        }
8279    }
8280}
8281
8282/// View column definition with optional COMMENT and OPTIONS (BigQuery)
8283#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8284#[cfg_attr(feature = "bindings", derive(TS))]
8285pub struct ViewColumn {
8286    pub name: Identifier,
8287    pub comment: Option<String>,
8288    /// BigQuery: OPTIONS (key=value, ...) on column
8289    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8290    pub options: Vec<Expression>,
8291}
8292
8293impl ViewColumn {
8294    pub fn new(name: impl Into<String>) -> Self {
8295        Self {
8296            name: Identifier::new(name),
8297            comment: None,
8298            options: Vec::new(),
8299        }
8300    }
8301
8302    pub fn with_comment(name: impl Into<String>, comment: impl Into<String>) -> Self {
8303        Self {
8304            name: Identifier::new(name),
8305            comment: Some(comment.into()),
8306            options: Vec::new(),
8307        }
8308    }
8309}
8310
8311/// CREATE VIEW statement
8312#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8313#[cfg_attr(feature = "bindings", derive(TS))]
8314pub struct CreateView {
8315    pub name: TableRef,
8316    pub columns: Vec<ViewColumn>,
8317    pub query: Expression,
8318    pub or_replace: bool,
8319    /// TSQL: CREATE OR ALTER
8320    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
8321    pub or_alter: bool,
8322    pub if_not_exists: bool,
8323    pub materialized: bool,
8324    pub temporary: bool,
8325    /// Snowflake: SECURE VIEW
8326    #[serde(default)]
8327    pub secure: bool,
8328    /// MySQL: ALGORITHM=UNDEFINED/MERGE/TEMPTABLE
8329    #[serde(skip_serializing_if = "Option::is_none")]
8330    pub algorithm: Option<String>,
8331    /// MySQL: DEFINER=user@host
8332    #[serde(skip_serializing_if = "Option::is_none")]
8333    pub definer: Option<String>,
8334    /// MySQL: SQL SECURITY DEFINER/INVOKER; Presto: SECURITY DEFINER/INVOKER
8335    #[serde(skip_serializing_if = "Option::is_none")]
8336    pub security: Option<FunctionSecurity>,
8337    /// True for MySQL-style "SQL SECURITY", false for Presto-style "SECURITY"
8338    #[serde(default = "default_true")]
8339    pub security_sql_style: bool,
8340    /// True when SQL SECURITY appears after the view name (not before VIEW keyword)
8341    #[serde(default)]
8342    pub security_after_name: bool,
8343    /// Whether the query was parenthesized: AS (SELECT ...)
8344    #[serde(default)]
8345    pub query_parenthesized: bool,
8346    /// Teradata: LOCKING mode (ROW, TABLE, DATABASE)
8347    #[serde(skip_serializing_if = "Option::is_none")]
8348    pub locking_mode: Option<String>,
8349    /// Teradata: LOCKING access type (ACCESS, READ, WRITE)
8350    #[serde(skip_serializing_if = "Option::is_none")]
8351    pub locking_access: Option<String>,
8352    /// Snowflake: COPY GRANTS
8353    #[serde(default)]
8354    pub copy_grants: bool,
8355    /// Snowflake: COMMENT = 'text'
8356    #[serde(skip_serializing_if = "Option::is_none", default)]
8357    pub comment: Option<String>,
8358    /// Snowflake: TAG (name='value', ...)
8359    #[serde(default)]
8360    pub tags: Vec<(String, String)>,
8361    /// BigQuery: OPTIONS (key=value, ...)
8362    #[serde(default)]
8363    pub options: Vec<Expression>,
8364    /// Doris: BUILD IMMEDIATE/DEFERRED for materialized views
8365    #[serde(skip_serializing_if = "Option::is_none", default)]
8366    pub build: Option<String>,
8367    /// Doris: REFRESH property for materialized views
8368    #[serde(skip_serializing_if = "Option::is_none", default)]
8369    pub refresh: Option<Box<RefreshTriggerProperty>>,
8370    /// Doris: Schema with typed column definitions for materialized views
8371    /// This is used instead of `columns` when the view has typed column definitions
8372    #[serde(skip_serializing_if = "Option::is_none", default)]
8373    pub schema: Option<Box<Schema>>,
8374    /// Doris: KEY (columns) for materialized views
8375    #[serde(skip_serializing_if = "Option::is_none", default)]
8376    pub unique_key: Option<Box<UniqueKeyProperty>>,
8377    /// Redshift: WITH NO SCHEMA BINDING
8378    #[serde(default)]
8379    pub no_schema_binding: bool,
8380    /// Redshift: AUTO REFRESH YES|NO for materialized views
8381    #[serde(skip_serializing_if = "Option::is_none", default)]
8382    pub auto_refresh: Option<bool>,
8383    /// ClickHouse: ON CLUSTER clause
8384    #[serde(default, skip_serializing_if = "Option::is_none")]
8385    pub on_cluster: Option<OnCluster>,
8386    /// ClickHouse: TO destination_table
8387    #[serde(default, skip_serializing_if = "Option::is_none")]
8388    pub to_table: Option<TableRef>,
8389    /// ClickHouse: Table properties (ENGINE, ORDER BY, SAMPLE, SETTINGS, TTL, etc.) for materialized views
8390    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8391    pub table_properties: Vec<Expression>,
8392}
8393
8394impl CreateView {
8395    pub fn new(name: impl Into<String>, query: Expression) -> Self {
8396        Self {
8397            name: TableRef::new(name),
8398            columns: Vec::new(),
8399            query,
8400            or_replace: false,
8401            or_alter: false,
8402            if_not_exists: false,
8403            materialized: false,
8404            temporary: false,
8405            secure: false,
8406            algorithm: None,
8407            definer: None,
8408            security: None,
8409            security_sql_style: true,
8410            security_after_name: false,
8411            query_parenthesized: false,
8412            locking_mode: None,
8413            locking_access: None,
8414            copy_grants: false,
8415            comment: None,
8416            tags: Vec::new(),
8417            options: Vec::new(),
8418            build: None,
8419            refresh: None,
8420            schema: None,
8421            unique_key: None,
8422            no_schema_binding: false,
8423            auto_refresh: None,
8424            on_cluster: None,
8425            to_table: None,
8426            table_properties: Vec::new(),
8427        }
8428    }
8429}
8430
8431/// DROP VIEW statement
8432#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8433#[cfg_attr(feature = "bindings", derive(TS))]
8434pub struct DropView {
8435    pub name: TableRef,
8436    pub if_exists: bool,
8437    pub materialized: bool,
8438}
8439
8440impl DropView {
8441    pub fn new(name: impl Into<String>) -> Self {
8442        Self {
8443            name: TableRef::new(name),
8444            if_exists: false,
8445            materialized: false,
8446        }
8447    }
8448}
8449
8450/// TRUNCATE TABLE statement
8451#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8452#[cfg_attr(feature = "bindings", derive(TS))]
8453pub struct Truncate {
8454    /// Target of TRUNCATE (TABLE vs DATABASE)
8455    #[serde(default)]
8456    pub target: TruncateTarget,
8457    /// IF EXISTS clause
8458    #[serde(default)]
8459    pub if_exists: bool,
8460    pub table: TableRef,
8461    /// ClickHouse: ON CLUSTER clause for distributed DDL
8462    #[serde(default, skip_serializing_if = "Option::is_none")]
8463    pub on_cluster: Option<OnCluster>,
8464    pub cascade: bool,
8465    /// Additional tables for multi-table TRUNCATE
8466    #[serde(default)]
8467    pub extra_tables: Vec<TruncateTableEntry>,
8468    /// RESTART IDENTITY or CONTINUE IDENTITY
8469    #[serde(default)]
8470    pub identity: Option<TruncateIdentity>,
8471    /// RESTRICT option (alternative to CASCADE)
8472    #[serde(default)]
8473    pub restrict: bool,
8474    /// Hive PARTITION clause: PARTITION(key=value, ...)
8475    #[serde(default, skip_serializing_if = "Option::is_none")]
8476    pub partition: Option<Box<Expression>>,
8477}
8478
8479/// A table entry in a TRUNCATE statement, with optional ONLY modifier and * suffix
8480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8481#[cfg_attr(feature = "bindings", derive(TS))]
8482pub struct TruncateTableEntry {
8483    pub table: TableRef,
8484    /// Whether the table has a * suffix (inherit children)
8485    #[serde(default)]
8486    pub star: bool,
8487}
8488
8489/// TRUNCATE target type
8490#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
8491#[cfg_attr(feature = "bindings", derive(TS))]
8492pub enum TruncateTarget {
8493    Table,
8494    Database,
8495}
8496
8497impl Default for TruncateTarget {
8498    fn default() -> Self {
8499        TruncateTarget::Table
8500    }
8501}
8502
8503/// TRUNCATE identity option
8504#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
8505#[cfg_attr(feature = "bindings", derive(TS))]
8506pub enum TruncateIdentity {
8507    Restart,
8508    Continue,
8509}
8510
8511impl Truncate {
8512    pub fn new(table: impl Into<String>) -> Self {
8513        Self {
8514            target: TruncateTarget::Table,
8515            if_exists: false,
8516            table: TableRef::new(table),
8517            on_cluster: None,
8518            cascade: false,
8519            extra_tables: Vec::new(),
8520            identity: None,
8521            restrict: false,
8522            partition: None,
8523        }
8524    }
8525}
8526
8527/// USE statement (USE database, USE ROLE, USE WAREHOUSE, USE CATALOG, USE SCHEMA)
8528#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8529#[cfg_attr(feature = "bindings", derive(TS))]
8530pub struct Use {
8531    /// The kind of object (DATABASE, SCHEMA, ROLE, WAREHOUSE, CATALOG, or None for default)
8532    pub kind: Option<UseKind>,
8533    /// The name of the object
8534    pub this: Identifier,
8535}
8536
8537/// Kind of USE statement
8538#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
8539#[cfg_attr(feature = "bindings", derive(TS))]
8540pub enum UseKind {
8541    Database,
8542    Schema,
8543    Role,
8544    Warehouse,
8545    Catalog,
8546    /// Snowflake: USE SECONDARY ROLES ALL|NONE
8547    SecondaryRoles,
8548}
8549
8550/// SET variable statement
8551#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8552#[cfg_attr(feature = "bindings", derive(TS))]
8553pub struct SetStatement {
8554    /// The items being set
8555    pub items: Vec<SetItem>,
8556}
8557
8558/// A single SET item (variable assignment)
8559#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8560#[cfg_attr(feature = "bindings", derive(TS))]
8561pub struct SetItem {
8562    /// The variable name
8563    pub name: Expression,
8564    /// The value to set
8565    pub value: Expression,
8566    /// Kind: None for plain SET, Some("GLOBAL") for SET GLOBAL, etc.
8567    pub kind: Option<String>,
8568    /// Whether the SET item was parsed without an = sign (TSQL: SET KEY VALUE)
8569    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
8570    pub no_equals: bool,
8571}
8572
8573/// CACHE TABLE statement (Spark)
8574#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8575#[cfg_attr(feature = "bindings", derive(TS))]
8576pub struct Cache {
8577    /// The table to cache
8578    pub table: Identifier,
8579    /// LAZY keyword - defer caching until first use
8580    pub lazy: bool,
8581    /// Optional OPTIONS clause (key-value pairs)
8582    pub options: Vec<(Expression, Expression)>,
8583    /// Optional AS clause with query
8584    pub query: Option<Expression>,
8585}
8586
8587/// UNCACHE TABLE statement (Spark)
8588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8589#[cfg_attr(feature = "bindings", derive(TS))]
8590pub struct Uncache {
8591    /// The table to uncache
8592    pub table: Identifier,
8593    /// IF EXISTS clause
8594    pub if_exists: bool,
8595}
8596
8597/// LOAD DATA statement (Hive)
8598#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8599#[cfg_attr(feature = "bindings", derive(TS))]
8600pub struct LoadData {
8601    /// LOCAL keyword - load from local filesystem
8602    pub local: bool,
8603    /// The path to load data from (INPATH value)
8604    pub inpath: String,
8605    /// Whether to overwrite existing data
8606    pub overwrite: bool,
8607    /// The target table
8608    pub table: Expression,
8609    /// Optional PARTITION clause with key-value pairs
8610    pub partition: Vec<(Identifier, Expression)>,
8611    /// Optional INPUTFORMAT clause
8612    pub input_format: Option<String>,
8613    /// Optional SERDE clause
8614    pub serde: Option<String>,
8615}
8616
8617/// PRAGMA statement (SQLite)
8618#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8619#[cfg_attr(feature = "bindings", derive(TS))]
8620pub struct Pragma {
8621    /// Optional schema prefix (e.g., "schema" in "schema.pragma_name")
8622    pub schema: Option<Identifier>,
8623    /// The pragma name
8624    pub name: Identifier,
8625    /// Optional value for assignment (PRAGMA name = value)
8626    pub value: Option<Expression>,
8627    /// Optional arguments for function-style pragmas (PRAGMA name(arg))
8628    pub args: Vec<Expression>,
8629}
8630
8631/// A privilege with optional column list for GRANT/REVOKE
8632/// Examples: SELECT, UPDATE(col1, col2), ALL(col1, col2, col3)
8633#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8634#[cfg_attr(feature = "bindings", derive(TS))]
8635pub struct Privilege {
8636    /// The privilege name (e.g., SELECT, INSERT, UPDATE, ALL)
8637    pub name: String,
8638    /// Optional column list for column-level privileges (e.g., UPDATE(col1, col2))
8639    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8640    pub columns: Vec<String>,
8641}
8642
8643/// Principal in GRANT/REVOKE (user, role, etc.)
8644#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8645#[cfg_attr(feature = "bindings", derive(TS))]
8646pub struct GrantPrincipal {
8647    /// The name of the principal
8648    pub name: Identifier,
8649    /// Whether prefixed with ROLE keyword
8650    pub is_role: bool,
8651    /// Whether prefixed with GROUP keyword (Redshift)
8652    #[serde(default)]
8653    pub is_group: bool,
8654    /// Whether prefixed with SHARE keyword (Snowflake)
8655    #[serde(default)]
8656    pub is_share: bool,
8657}
8658
8659/// GRANT statement
8660#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8661#[cfg_attr(feature = "bindings", derive(TS))]
8662pub struct Grant {
8663    /// Privileges to grant (e.g., SELECT, INSERT, UPDATE(col1, col2))
8664    pub privileges: Vec<Privilege>,
8665    /// Object kind (TABLE, SCHEMA, FUNCTION, etc.)
8666    pub kind: Option<String>,
8667    /// The object to grant on
8668    pub securable: Identifier,
8669    /// Function parameter types (for FUNCTION kind)
8670    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8671    pub function_params: Vec<String>,
8672    /// The grantees
8673    pub principals: Vec<GrantPrincipal>,
8674    /// WITH GRANT OPTION
8675    pub grant_option: bool,
8676    /// TSQL: AS principal (the grantor role)
8677    #[serde(default, skip_serializing_if = "Option::is_none")]
8678    pub as_principal: Option<Identifier>,
8679}
8680
8681/// REVOKE statement
8682#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8683#[cfg_attr(feature = "bindings", derive(TS))]
8684pub struct Revoke {
8685    /// Privileges to revoke (e.g., SELECT, INSERT, UPDATE(col1, col2))
8686    pub privileges: Vec<Privilege>,
8687    /// Object kind (TABLE, SCHEMA, FUNCTION, etc.)
8688    pub kind: Option<String>,
8689    /// The object to revoke from
8690    pub securable: Identifier,
8691    /// Function parameter types (for FUNCTION kind)
8692    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8693    pub function_params: Vec<String>,
8694    /// The grantees
8695    pub principals: Vec<GrantPrincipal>,
8696    /// GRANT OPTION FOR
8697    pub grant_option: bool,
8698    /// CASCADE
8699    pub cascade: bool,
8700    /// RESTRICT
8701    #[serde(default)]
8702    pub restrict: bool,
8703}
8704
8705/// COMMENT ON statement
8706#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8707#[cfg_attr(feature = "bindings", derive(TS))]
8708pub struct Comment {
8709    /// The object being commented on
8710    pub this: Expression,
8711    /// The object kind (COLUMN, TABLE, DATABASE, etc.)
8712    pub kind: String,
8713    /// The comment text expression
8714    pub expression: Expression,
8715    /// IF EXISTS clause
8716    pub exists: bool,
8717    /// MATERIALIZED keyword
8718    pub materialized: bool,
8719}
8720
8721// ============================================================================
8722// Phase 4: Additional DDL Statements
8723// ============================================================================
8724
8725/// ALTER VIEW statement
8726#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8727#[cfg_attr(feature = "bindings", derive(TS))]
8728pub struct AlterView {
8729    pub name: TableRef,
8730    pub actions: Vec<AlterViewAction>,
8731    /// MySQL: ALGORITHM = MERGE|TEMPTABLE|UNDEFINED
8732    #[serde(default, skip_serializing_if = "Option::is_none")]
8733    pub algorithm: Option<String>,
8734    /// MySQL: DEFINER = 'user'@'host'
8735    #[serde(default, skip_serializing_if = "Option::is_none")]
8736    pub definer: Option<String>,
8737    /// MySQL: SQL SECURITY = DEFINER|INVOKER
8738    #[serde(default, skip_serializing_if = "Option::is_none")]
8739    pub sql_security: Option<String>,
8740    /// TSQL: WITH option (SCHEMABINDING, ENCRYPTION, VIEW_METADATA)
8741    #[serde(default, skip_serializing_if = "Option::is_none")]
8742    pub with_option: Option<String>,
8743    /// Hive: Column aliases with optional comments: (c1 COMMENT 'text', c2)
8744    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8745    pub columns: Vec<ViewColumn>,
8746}
8747
8748/// Actions for ALTER VIEW
8749#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8750#[cfg_attr(feature = "bindings", derive(TS))]
8751pub enum AlterViewAction {
8752    /// Rename the view
8753    Rename(TableRef),
8754    /// Change owner
8755    OwnerTo(Identifier),
8756    /// Set schema
8757    SetSchema(Identifier),
8758    /// Set authorization (Trino/Presto)
8759    SetAuthorization(String),
8760    /// Alter column
8761    AlterColumn {
8762        name: Identifier,
8763        action: AlterColumnAction,
8764    },
8765    /// Redefine view as query (SELECT, UNION, etc.)
8766    AsSelect(Box<Expression>),
8767    /// Hive: SET TBLPROPERTIES ('key'='value', ...)
8768    SetTblproperties(Vec<(String, String)>),
8769    /// Hive: UNSET TBLPROPERTIES ('key1', 'key2', ...)
8770    UnsetTblproperties(Vec<String>),
8771}
8772
8773impl AlterView {
8774    pub fn new(name: impl Into<String>) -> Self {
8775        Self {
8776            name: TableRef::new(name),
8777            actions: Vec::new(),
8778            algorithm: None,
8779            definer: None,
8780            sql_security: None,
8781            with_option: None,
8782            columns: Vec::new(),
8783        }
8784    }
8785}
8786
8787/// ALTER INDEX statement
8788#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8789#[cfg_attr(feature = "bindings", derive(TS))]
8790pub struct AlterIndex {
8791    pub name: Identifier,
8792    pub table: Option<TableRef>,
8793    pub actions: Vec<AlterIndexAction>,
8794}
8795
8796/// Actions for ALTER INDEX
8797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8798#[cfg_attr(feature = "bindings", derive(TS))]
8799pub enum AlterIndexAction {
8800    /// Rename the index
8801    Rename(Identifier),
8802    /// Set tablespace
8803    SetTablespace(Identifier),
8804    /// Set visibility (MySQL)
8805    Visible(bool),
8806}
8807
8808impl AlterIndex {
8809    pub fn new(name: impl Into<String>) -> Self {
8810        Self {
8811            name: Identifier::new(name),
8812            table: None,
8813            actions: Vec::new(),
8814        }
8815    }
8816}
8817
8818/// CREATE SCHEMA statement
8819#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8820#[cfg_attr(feature = "bindings", derive(TS))]
8821pub struct CreateSchema {
8822    /// Schema name parts, possibly dot-qualified (e.g. [mydb, hr] for "mydb.hr")
8823    pub name: Vec<Identifier>,
8824    pub if_not_exists: bool,
8825    pub authorization: Option<Identifier>,
8826    /// CLONE source parts, possibly dot-qualified
8827    #[serde(default)]
8828    pub clone_from: Option<Vec<Identifier>>,
8829    /// AT/BEFORE clause for time travel (Snowflake)
8830    #[serde(default)]
8831    pub at_clause: Option<Expression>,
8832    /// Schema properties like DEFAULT COLLATE
8833    #[serde(default)]
8834    pub properties: Vec<Expression>,
8835    /// Leading comments before the statement
8836    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8837    pub leading_comments: Vec<String>,
8838}
8839
8840impl CreateSchema {
8841    pub fn new(name: impl Into<String>) -> Self {
8842        Self {
8843            name: vec![Identifier::new(name)],
8844            if_not_exists: false,
8845            authorization: None,
8846            clone_from: None,
8847            at_clause: None,
8848            properties: Vec::new(),
8849            leading_comments: Vec::new(),
8850        }
8851    }
8852}
8853
8854/// DROP SCHEMA statement
8855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8856#[cfg_attr(feature = "bindings", derive(TS))]
8857pub struct DropSchema {
8858    pub name: Identifier,
8859    pub if_exists: bool,
8860    pub cascade: bool,
8861}
8862
8863impl DropSchema {
8864    pub fn new(name: impl Into<String>) -> Self {
8865        Self {
8866            name: Identifier::new(name),
8867            if_exists: false,
8868            cascade: false,
8869        }
8870    }
8871}
8872
8873/// DROP NAMESPACE statement (Spark/Databricks - alias for DROP SCHEMA)
8874#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8875#[cfg_attr(feature = "bindings", derive(TS))]
8876pub struct DropNamespace {
8877    pub name: Identifier,
8878    pub if_exists: bool,
8879    pub cascade: bool,
8880}
8881
8882impl DropNamespace {
8883    pub fn new(name: impl Into<String>) -> Self {
8884        Self {
8885            name: Identifier::new(name),
8886            if_exists: false,
8887            cascade: false,
8888        }
8889    }
8890}
8891
8892/// CREATE DATABASE statement
8893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8894#[cfg_attr(feature = "bindings", derive(TS))]
8895pub struct CreateDatabase {
8896    pub name: Identifier,
8897    pub if_not_exists: bool,
8898    pub options: Vec<DatabaseOption>,
8899    /// Snowflake CLONE source
8900    #[serde(default)]
8901    pub clone_from: Option<Identifier>,
8902    /// AT/BEFORE clause for time travel (Snowflake)
8903    #[serde(default)]
8904    pub at_clause: Option<Expression>,
8905}
8906
8907/// Database option
8908#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8909#[cfg_attr(feature = "bindings", derive(TS))]
8910pub enum DatabaseOption {
8911    CharacterSet(String),
8912    Collate(String),
8913    Owner(Identifier),
8914    Template(Identifier),
8915    Encoding(String),
8916    Location(String),
8917}
8918
8919impl CreateDatabase {
8920    pub fn new(name: impl Into<String>) -> Self {
8921        Self {
8922            name: Identifier::new(name),
8923            if_not_exists: false,
8924            options: Vec::new(),
8925            clone_from: None,
8926            at_clause: None,
8927        }
8928    }
8929}
8930
8931/// DROP DATABASE statement
8932#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8933#[cfg_attr(feature = "bindings", derive(TS))]
8934pub struct DropDatabase {
8935    pub name: Identifier,
8936    pub if_exists: bool,
8937    /// ClickHouse: SYNC modifier
8938    #[serde(default)]
8939    pub sync: bool,
8940}
8941
8942impl DropDatabase {
8943    pub fn new(name: impl Into<String>) -> Self {
8944        Self {
8945            name: Identifier::new(name),
8946            if_exists: false,
8947            sync: false,
8948        }
8949    }
8950}
8951
8952/// CREATE FUNCTION statement
8953#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8954#[cfg_attr(feature = "bindings", derive(TS))]
8955pub struct CreateFunction {
8956    pub name: TableRef,
8957    pub parameters: Vec<FunctionParameter>,
8958    pub return_type: Option<DataType>,
8959    pub body: Option<FunctionBody>,
8960    pub or_replace: bool,
8961    /// TSQL: CREATE OR ALTER
8962    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
8963    pub or_alter: bool,
8964    pub if_not_exists: bool,
8965    pub temporary: bool,
8966    pub language: Option<String>,
8967    pub deterministic: Option<bool>,
8968    pub returns_null_on_null_input: Option<bool>,
8969    pub security: Option<FunctionSecurity>,
8970    /// Whether parentheses were present in the original syntax
8971    #[serde(default = "default_true")]
8972    pub has_parens: bool,
8973    /// SQL data access characteristic (CONTAINS SQL, READS SQL DATA, etc.)
8974    #[serde(default)]
8975    pub sql_data_access: Option<SqlDataAccess>,
8976    /// TSQL: RETURNS @var TABLE (col_defs) - stores the variable name and column definitions as raw string
8977    #[serde(default, skip_serializing_if = "Option::is_none")]
8978    pub returns_table_body: Option<String>,
8979    /// True if LANGUAGE clause appears before RETURNS clause
8980    #[serde(default)]
8981    pub language_first: bool,
8982    /// PostgreSQL SET options: SET key = value, SET key FROM CURRENT
8983    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8984    pub set_options: Vec<FunctionSetOption>,
8985    /// True if STRICT was used instead of RETURNS NULL ON NULL INPUT
8986    #[serde(default)]
8987    pub strict: bool,
8988    /// BigQuery: OPTIONS (key=value, ...)
8989    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8990    pub options: Vec<Expression>,
8991    /// BigQuery: True if this is a TABLE FUNCTION (CREATE TABLE FUNCTION)
8992    #[serde(default)]
8993    pub is_table_function: bool,
8994    /// Original order of function properties (SET, AS, LANGUAGE, etc.)
8995    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8996    pub property_order: Vec<FunctionPropertyKind>,
8997    /// Databricks: ENVIRONMENT (dependencies = '...', environment_version = '...')
8998    #[serde(default, skip_serializing_if = "Vec::is_empty")]
8999    pub environment: Vec<Expression>,
9000    /// HANDLER 'handler_function' clause (Databricks)
9001    #[serde(default, skip_serializing_if = "Option::is_none")]
9002    pub handler: Option<String>,
9003    /// PARAMETER STYLE clause (e.g., PANDAS for Databricks)
9004    #[serde(default, skip_serializing_if = "Option::is_none")]
9005    pub parameter_style: Option<String>,
9006}
9007
9008/// A SET option in CREATE FUNCTION (PostgreSQL)
9009#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9010#[cfg_attr(feature = "bindings", derive(TS))]
9011pub struct FunctionSetOption {
9012    pub name: String,
9013    pub value: FunctionSetValue,
9014}
9015
9016/// The value of a SET option
9017#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9018#[cfg_attr(feature = "bindings", derive(TS))]
9019pub enum FunctionSetValue {
9020    /// SET key = value (use_to = false) or SET key TO value (use_to = true)
9021    Value { value: String, use_to: bool },
9022    /// SET key FROM CURRENT
9023    FromCurrent,
9024}
9025
9026/// SQL data access characteristics for functions
9027#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9028#[cfg_attr(feature = "bindings", derive(TS))]
9029pub enum SqlDataAccess {
9030    /// NO SQL
9031    NoSql,
9032    /// CONTAINS SQL
9033    ContainsSql,
9034    /// READS SQL DATA
9035    ReadsSqlData,
9036    /// MODIFIES SQL DATA
9037    ModifiesSqlData,
9038}
9039
9040/// Types of properties in CREATE FUNCTION for tracking their original order
9041#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9042#[cfg_attr(feature = "bindings", derive(TS))]
9043pub enum FunctionPropertyKind {
9044    /// SET option
9045    Set,
9046    /// AS body
9047    As,
9048    /// LANGUAGE clause
9049    Language,
9050    /// IMMUTABLE/VOLATILE/STABLE (determinism)
9051    Determinism,
9052    /// CALLED ON NULL INPUT / RETURNS NULL ON NULL INPUT / STRICT
9053    NullInput,
9054    /// SECURITY DEFINER/INVOKER
9055    Security,
9056    /// SQL data access (CONTAINS SQL, READS SQL DATA, etc.)
9057    SqlDataAccess,
9058    /// OPTIONS clause (BigQuery)
9059    Options,
9060    /// ENVIRONMENT clause (Databricks)
9061    Environment,
9062    /// HANDLER clause (Databricks)
9063    Handler,
9064    /// PARAMETER STYLE clause (Databricks)
9065    ParameterStyle,
9066}
9067
9068/// Function parameter
9069#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9070#[cfg_attr(feature = "bindings", derive(TS))]
9071pub struct FunctionParameter {
9072    pub name: Option<Identifier>,
9073    pub data_type: DataType,
9074    pub mode: Option<ParameterMode>,
9075    pub default: Option<Expression>,
9076    /// Original text of the mode keyword for case-preserving output (e.g., "inout", "VARIADIC")
9077    #[serde(default, skip_serializing_if = "Option::is_none")]
9078    pub mode_text: Option<String>,
9079}
9080
9081/// Parameter mode (IN, OUT, INOUT, VARIADIC)
9082#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9083#[cfg_attr(feature = "bindings", derive(TS))]
9084pub enum ParameterMode {
9085    In,
9086    Out,
9087    InOut,
9088    Variadic,
9089}
9090
9091/// Function body
9092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9093#[cfg_attr(feature = "bindings", derive(TS))]
9094pub enum FunctionBody {
9095    /// AS $$ ... $$ (dollar-quoted)
9096    Block(String),
9097    /// AS 'string' (single-quoted string literal body)
9098    StringLiteral(String),
9099    /// AS 'expression'
9100    Expression(Expression),
9101    /// EXTERNAL NAME 'library'
9102    External(String),
9103    /// RETURN expression
9104    Return(Expression),
9105    /// BEGIN ... END block with parsed statements
9106    Statements(Vec<Expression>),
9107    /// AS $$...$$ or $tag$...$tag$ (dollar-quoted with optional tag)
9108    /// Stores (content, optional_tag)
9109    DollarQuoted {
9110        content: String,
9111        tag: Option<String>,
9112    },
9113}
9114
9115/// Function security (DEFINER, INVOKER, or NONE)
9116#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9117#[cfg_attr(feature = "bindings", derive(TS))]
9118pub enum FunctionSecurity {
9119    Definer,
9120    Invoker,
9121    /// StarRocks/MySQL: SECURITY NONE
9122    None,
9123}
9124
9125impl CreateFunction {
9126    pub fn new(name: impl Into<String>) -> Self {
9127        Self {
9128            name: TableRef::new(name),
9129            parameters: Vec::new(),
9130            return_type: None,
9131            body: None,
9132            or_replace: false,
9133            or_alter: false,
9134            if_not_exists: false,
9135            temporary: false,
9136            language: None,
9137            deterministic: None,
9138            returns_null_on_null_input: None,
9139            security: None,
9140            has_parens: true,
9141            sql_data_access: None,
9142            returns_table_body: None,
9143            language_first: false,
9144            set_options: Vec::new(),
9145            strict: false,
9146            options: Vec::new(),
9147            is_table_function: false,
9148            property_order: Vec::new(),
9149            environment: Vec::new(),
9150            handler: None,
9151            parameter_style: None,
9152        }
9153    }
9154}
9155
9156/// DROP FUNCTION statement
9157#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9158#[cfg_attr(feature = "bindings", derive(TS))]
9159pub struct DropFunction {
9160    pub name: TableRef,
9161    pub parameters: Option<Vec<DataType>>,
9162    pub if_exists: bool,
9163    pub cascade: bool,
9164}
9165
9166impl DropFunction {
9167    pub fn new(name: impl Into<String>) -> Self {
9168        Self {
9169            name: TableRef::new(name),
9170            parameters: None,
9171            if_exists: false,
9172            cascade: false,
9173        }
9174    }
9175}
9176
9177/// CREATE PROCEDURE statement
9178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9179#[cfg_attr(feature = "bindings", derive(TS))]
9180pub struct CreateProcedure {
9181    pub name: TableRef,
9182    pub parameters: Vec<FunctionParameter>,
9183    pub body: Option<FunctionBody>,
9184    pub or_replace: bool,
9185    /// TSQL: CREATE OR ALTER
9186    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9187    pub or_alter: bool,
9188    pub if_not_exists: bool,
9189    pub language: Option<String>,
9190    pub security: Option<FunctionSecurity>,
9191    /// Return type (Snowflake: RETURNS OBJECT, RETURNS VARCHAR, etc.)
9192    #[serde(default)]
9193    pub return_type: Option<DataType>,
9194    /// Execution context (EXECUTE AS CALLER, EXECUTE AS OWNER)
9195    #[serde(default)]
9196    pub execute_as: Option<String>,
9197    /// TSQL WITH options (ENCRYPTION, RECOMPILE, SCHEMABINDING, etc.)
9198    #[serde(default, skip_serializing_if = "Vec::is_empty")]
9199    pub with_options: Vec<String>,
9200    /// Whether the parameter list had parentheses (false for TSQL procedures without parens)
9201    #[serde(default = "default_true", skip_serializing_if = "is_true")]
9202    pub has_parens: bool,
9203    /// Whether the short form PROC was used (instead of PROCEDURE)
9204    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9205    pub use_proc_keyword: bool,
9206}
9207
9208impl CreateProcedure {
9209    pub fn new(name: impl Into<String>) -> Self {
9210        Self {
9211            name: TableRef::new(name),
9212            parameters: Vec::new(),
9213            body: None,
9214            or_replace: false,
9215            or_alter: false,
9216            if_not_exists: false,
9217            language: None,
9218            security: None,
9219            return_type: None,
9220            execute_as: None,
9221            with_options: Vec::new(),
9222            has_parens: true,
9223            use_proc_keyword: false,
9224        }
9225    }
9226}
9227
9228/// DROP PROCEDURE statement
9229#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9230#[cfg_attr(feature = "bindings", derive(TS))]
9231pub struct DropProcedure {
9232    pub name: TableRef,
9233    pub parameters: Option<Vec<DataType>>,
9234    pub if_exists: bool,
9235    pub cascade: bool,
9236}
9237
9238impl DropProcedure {
9239    pub fn new(name: impl Into<String>) -> Self {
9240        Self {
9241            name: TableRef::new(name),
9242            parameters: None,
9243            if_exists: false,
9244            cascade: false,
9245        }
9246    }
9247}
9248
9249/// Sequence property tag for ordering
9250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9251#[cfg_attr(feature = "bindings", derive(TS))]
9252pub enum SeqPropKind {
9253    Start,
9254    Increment,
9255    Minvalue,
9256    Maxvalue,
9257    Cache,
9258    NoCache,
9259    Cycle,
9260    NoCycle,
9261    OwnedBy,
9262    Order,
9263    NoOrder,
9264    Comment,
9265    /// SHARING=<value> (Oracle)
9266    Sharing,
9267    /// KEEP (Oracle)
9268    Keep,
9269    /// NOKEEP (Oracle)
9270    NoKeep,
9271    /// SCALE [EXTEND|NOEXTEND] (Oracle)
9272    Scale,
9273    /// NOSCALE (Oracle)
9274    NoScale,
9275    /// SHARD [EXTEND|NOEXTEND] (Oracle)
9276    Shard,
9277    /// NOSHARD (Oracle)
9278    NoShard,
9279    /// SESSION (Oracle)
9280    Session,
9281    /// GLOBAL (Oracle)
9282    Global,
9283    /// NOCACHE (single word, Oracle)
9284    NoCacheWord,
9285    /// NOCYCLE (single word, Oracle)
9286    NoCycleWord,
9287    /// NOMINVALUE (single word, Oracle)
9288    NoMinvalueWord,
9289    /// NOMAXVALUE (single word, Oracle)
9290    NoMaxvalueWord,
9291}
9292
9293/// CREATE SYNONYM statement (TSQL)
9294#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9295#[cfg_attr(feature = "bindings", derive(TS))]
9296pub struct CreateSynonym {
9297    /// The synonym name (can be qualified: schema.synonym_name)
9298    pub name: TableRef,
9299    /// The target object the synonym refers to
9300    pub target: TableRef,
9301}
9302
9303/// CREATE SEQUENCE statement
9304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9305#[cfg_attr(feature = "bindings", derive(TS))]
9306pub struct CreateSequence {
9307    pub name: TableRef,
9308    pub if_not_exists: bool,
9309    pub temporary: bool,
9310    #[serde(default)]
9311    pub or_replace: bool,
9312    /// AS <type> clause (e.g., AS SMALLINT, AS BIGINT)
9313    #[serde(default, skip_serializing_if = "Option::is_none")]
9314    pub as_type: Option<DataType>,
9315    pub increment: Option<i64>,
9316    pub minvalue: Option<SequenceBound>,
9317    pub maxvalue: Option<SequenceBound>,
9318    pub start: Option<i64>,
9319    pub cache: Option<i64>,
9320    pub cycle: bool,
9321    pub owned_by: Option<TableRef>,
9322    /// Whether OWNED BY NONE was specified
9323    #[serde(default)]
9324    pub owned_by_none: bool,
9325    /// Snowflake: ORDER or NOORDER (true = ORDER, false = NOORDER, None = not specified)
9326    #[serde(default)]
9327    pub order: Option<bool>,
9328    /// Snowflake: COMMENT = 'value'
9329    #[serde(default)]
9330    pub comment: Option<String>,
9331    /// SHARING=<value> (Oracle)
9332    #[serde(default, skip_serializing_if = "Option::is_none")]
9333    pub sharing: Option<String>,
9334    /// SCALE modifier: Some("EXTEND"), Some("NOEXTEND"), Some("") for plain SCALE
9335    #[serde(default, skip_serializing_if = "Option::is_none")]
9336    pub scale_modifier: Option<String>,
9337    /// SHARD modifier: Some("EXTEND"), Some("NOEXTEND"), Some("") for plain SHARD
9338    #[serde(default, skip_serializing_if = "Option::is_none")]
9339    pub shard_modifier: Option<String>,
9340    /// Tracks the order in which properties appeared in the source
9341    #[serde(default)]
9342    pub property_order: Vec<SeqPropKind>,
9343}
9344
9345/// Sequence bound (value or NO MINVALUE/NO MAXVALUE)
9346#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9347#[cfg_attr(feature = "bindings", derive(TS))]
9348pub enum SequenceBound {
9349    Value(i64),
9350    None,
9351}
9352
9353impl CreateSequence {
9354    pub fn new(name: impl Into<String>) -> Self {
9355        Self {
9356            name: TableRef::new(name),
9357            if_not_exists: false,
9358            temporary: false,
9359            or_replace: false,
9360            as_type: None,
9361            increment: None,
9362            minvalue: None,
9363            maxvalue: None,
9364            start: None,
9365            cache: None,
9366            cycle: false,
9367            owned_by: None,
9368            owned_by_none: false,
9369            order: None,
9370            comment: None,
9371            sharing: None,
9372            scale_modifier: None,
9373            shard_modifier: None,
9374            property_order: Vec::new(),
9375        }
9376    }
9377}
9378
9379/// DROP SEQUENCE statement
9380#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9381#[cfg_attr(feature = "bindings", derive(TS))]
9382pub struct DropSequence {
9383    pub name: TableRef,
9384    pub if_exists: bool,
9385    pub cascade: bool,
9386}
9387
9388impl DropSequence {
9389    pub fn new(name: impl Into<String>) -> Self {
9390        Self {
9391            name: TableRef::new(name),
9392            if_exists: false,
9393            cascade: false,
9394        }
9395    }
9396}
9397
9398/// ALTER SEQUENCE statement
9399#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9400#[cfg_attr(feature = "bindings", derive(TS))]
9401pub struct AlterSequence {
9402    pub name: TableRef,
9403    pub if_exists: bool,
9404    pub increment: Option<i64>,
9405    pub minvalue: Option<SequenceBound>,
9406    pub maxvalue: Option<SequenceBound>,
9407    pub start: Option<i64>,
9408    pub restart: Option<Option<i64>>,
9409    pub cache: Option<i64>,
9410    pub cycle: Option<bool>,
9411    pub owned_by: Option<Option<TableRef>>,
9412}
9413
9414impl AlterSequence {
9415    pub fn new(name: impl Into<String>) -> Self {
9416        Self {
9417            name: TableRef::new(name),
9418            if_exists: false,
9419            increment: None,
9420            minvalue: None,
9421            maxvalue: None,
9422            start: None,
9423            restart: None,
9424            cache: None,
9425            cycle: None,
9426            owned_by: None,
9427        }
9428    }
9429}
9430
9431/// CREATE TRIGGER statement
9432#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9433#[cfg_attr(feature = "bindings", derive(TS))]
9434pub struct CreateTrigger {
9435    pub name: Identifier,
9436    pub table: TableRef,
9437    pub timing: TriggerTiming,
9438    pub events: Vec<TriggerEvent>,
9439    #[serde(default, skip_serializing_if = "Option::is_none")]
9440    pub for_each: Option<TriggerForEach>,
9441    pub when: Option<Expression>,
9442    /// Whether the WHEN clause was parenthesized in the original SQL
9443    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9444    pub when_paren: bool,
9445    pub body: TriggerBody,
9446    pub or_replace: bool,
9447    /// TSQL: CREATE OR ALTER
9448    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9449    pub or_alter: bool,
9450    pub constraint: bool,
9451    pub deferrable: Option<bool>,
9452    pub initially_deferred: Option<bool>,
9453    pub referencing: Option<TriggerReferencing>,
9454}
9455
9456/// Trigger timing (BEFORE, AFTER, INSTEAD OF)
9457#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9458#[cfg_attr(feature = "bindings", derive(TS))]
9459pub enum TriggerTiming {
9460    Before,
9461    After,
9462    InsteadOf,
9463}
9464
9465/// Trigger event (INSERT, UPDATE, DELETE, TRUNCATE)
9466#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9467#[cfg_attr(feature = "bindings", derive(TS))]
9468pub enum TriggerEvent {
9469    Insert,
9470    Update(Option<Vec<Identifier>>),
9471    Delete,
9472    Truncate,
9473}
9474
9475/// Trigger FOR EACH clause
9476#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9477#[cfg_attr(feature = "bindings", derive(TS))]
9478pub enum TriggerForEach {
9479    Row,
9480    Statement,
9481}
9482
9483/// Trigger body
9484#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9485#[cfg_attr(feature = "bindings", derive(TS))]
9486pub enum TriggerBody {
9487    /// EXECUTE FUNCTION/PROCEDURE name(args)
9488    Execute {
9489        function: TableRef,
9490        args: Vec<Expression>,
9491    },
9492    /// BEGIN ... END block
9493    Block(String),
9494}
9495
9496/// Trigger REFERENCING clause
9497#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9498#[cfg_attr(feature = "bindings", derive(TS))]
9499pub struct TriggerReferencing {
9500    pub old_table: Option<Identifier>,
9501    pub new_table: Option<Identifier>,
9502    pub old_row: Option<Identifier>,
9503    pub new_row: Option<Identifier>,
9504}
9505
9506impl CreateTrigger {
9507    pub fn new(name: impl Into<String>, table: impl Into<String>) -> Self {
9508        Self {
9509            name: Identifier::new(name),
9510            table: TableRef::new(table),
9511            timing: TriggerTiming::Before,
9512            events: Vec::new(),
9513            for_each: Some(TriggerForEach::Row),
9514            when: None,
9515            when_paren: false,
9516            body: TriggerBody::Execute {
9517                function: TableRef::new(""),
9518                args: Vec::new(),
9519            },
9520            or_replace: false,
9521            or_alter: false,
9522            constraint: false,
9523            deferrable: None,
9524            initially_deferred: None,
9525            referencing: None,
9526        }
9527    }
9528}
9529
9530/// DROP TRIGGER statement
9531#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9532#[cfg_attr(feature = "bindings", derive(TS))]
9533pub struct DropTrigger {
9534    pub name: Identifier,
9535    pub table: Option<TableRef>,
9536    pub if_exists: bool,
9537    pub cascade: bool,
9538}
9539
9540impl DropTrigger {
9541    pub fn new(name: impl Into<String>) -> Self {
9542        Self {
9543            name: Identifier::new(name),
9544            table: None,
9545            if_exists: false,
9546            cascade: false,
9547        }
9548    }
9549}
9550
9551/// CREATE TYPE statement
9552#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9553#[cfg_attr(feature = "bindings", derive(TS))]
9554pub struct CreateType {
9555    pub name: TableRef,
9556    pub definition: TypeDefinition,
9557    pub if_not_exists: bool,
9558}
9559
9560/// Type definition
9561#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9562#[cfg_attr(feature = "bindings", derive(TS))]
9563pub enum TypeDefinition {
9564    /// ENUM type: CREATE TYPE name AS ENUM ('val1', 'val2', ...)
9565    Enum(Vec<String>),
9566    /// Composite type: CREATE TYPE name AS (field1 type1, field2 type2, ...)
9567    Composite(Vec<TypeAttribute>),
9568    /// Range type: CREATE TYPE name AS RANGE (SUBTYPE = type, ...)
9569    Range {
9570        subtype: DataType,
9571        subtype_diff: Option<String>,
9572        canonical: Option<String>,
9573    },
9574    /// Base type (for advanced usage)
9575    Base {
9576        input: String,
9577        output: String,
9578        internallength: Option<i32>,
9579    },
9580    /// Domain type
9581    Domain {
9582        base_type: DataType,
9583        default: Option<Expression>,
9584        constraints: Vec<DomainConstraint>,
9585    },
9586}
9587
9588/// Type attribute for composite types
9589#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9590#[cfg_attr(feature = "bindings", derive(TS))]
9591pub struct TypeAttribute {
9592    pub name: Identifier,
9593    pub data_type: DataType,
9594    pub collate: Option<Identifier>,
9595}
9596
9597/// Domain constraint
9598#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9599#[cfg_attr(feature = "bindings", derive(TS))]
9600pub struct DomainConstraint {
9601    pub name: Option<Identifier>,
9602    pub check: Expression,
9603}
9604
9605impl CreateType {
9606    pub fn new_enum(name: impl Into<String>, values: Vec<String>) -> Self {
9607        Self {
9608            name: TableRef::new(name),
9609            definition: TypeDefinition::Enum(values),
9610            if_not_exists: false,
9611        }
9612    }
9613
9614    pub fn new_composite(name: impl Into<String>, attributes: Vec<TypeAttribute>) -> Self {
9615        Self {
9616            name: TableRef::new(name),
9617            definition: TypeDefinition::Composite(attributes),
9618            if_not_exists: false,
9619        }
9620    }
9621}
9622
9623/// DROP TYPE statement
9624#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9625#[cfg_attr(feature = "bindings", derive(TS))]
9626pub struct DropType {
9627    pub name: TableRef,
9628    pub if_exists: bool,
9629    pub cascade: bool,
9630}
9631
9632impl DropType {
9633    pub fn new(name: impl Into<String>) -> Self {
9634        Self {
9635            name: TableRef::new(name),
9636            if_exists: false,
9637            cascade: false,
9638        }
9639    }
9640}
9641
9642/// DESCRIBE statement - shows table structure or query plan
9643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9644#[cfg_attr(feature = "bindings", derive(TS))]
9645pub struct Describe {
9646    /// The target to describe (table name or query)
9647    pub target: Expression,
9648    /// EXTENDED format
9649    pub extended: bool,
9650    /// FORMATTED format
9651    pub formatted: bool,
9652    /// Object kind (e.g., "SEMANTIC VIEW", "TABLE", etc.)
9653    #[serde(default)]
9654    pub kind: Option<String>,
9655    /// Properties like type=stage
9656    #[serde(default)]
9657    pub properties: Vec<(String, String)>,
9658    /// Style keyword (e.g., "ANALYZE", "HISTORY")
9659    #[serde(default, skip_serializing_if = "Option::is_none")]
9660    pub style: Option<String>,
9661    /// Partition specification for DESCRIBE PARTITION
9662    #[serde(default)]
9663    pub partition: Option<Box<Expression>>,
9664    /// Leading comments before the statement
9665    #[serde(default)]
9666    pub leading_comments: Vec<String>,
9667    /// AS JSON suffix (Databricks)
9668    #[serde(default)]
9669    pub as_json: bool,
9670}
9671
9672impl Describe {
9673    pub fn new(target: Expression) -> Self {
9674        Self {
9675            target,
9676            extended: false,
9677            formatted: false,
9678            kind: None,
9679            properties: Vec::new(),
9680            style: None,
9681            partition: None,
9682            leading_comments: Vec::new(),
9683            as_json: false,
9684        }
9685    }
9686}
9687
9688/// SHOW statement - displays database objects
9689#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9690#[cfg_attr(feature = "bindings", derive(TS))]
9691pub struct Show {
9692    /// The thing to show (DATABASES, TABLES, SCHEMAS, etc.)
9693    pub this: String,
9694    /// Whether TERSE was specified
9695    #[serde(default)]
9696    pub terse: bool,
9697    /// Whether HISTORY was specified
9698    #[serde(default)]
9699    pub history: bool,
9700    /// LIKE pattern
9701    pub like: Option<Expression>,
9702    /// IN scope kind (ACCOUNT, DATABASE, SCHEMA, TABLE)
9703    pub scope_kind: Option<String>,
9704    /// IN scope object
9705    pub scope: Option<Expression>,
9706    /// STARTS WITH pattern
9707    pub starts_with: Option<Expression>,
9708    /// LIMIT clause
9709    pub limit: Option<Box<Limit>>,
9710    /// FROM clause (for specific object)
9711    pub from: Option<Expression>,
9712    /// WHERE clause (MySQL: SHOW STATUS WHERE ...)
9713    #[serde(default, skip_serializing_if = "Option::is_none")]
9714    pub where_clause: Option<Expression>,
9715    /// FOR target (MySQL: SHOW GRANTS FOR user, SHOW PROFILE ... FOR QUERY n)
9716    #[serde(default, skip_serializing_if = "Option::is_none")]
9717    pub for_target: Option<Expression>,
9718    /// Second FROM clause (MySQL: SHOW COLUMNS FROM tbl FROM db)
9719    #[serde(default, skip_serializing_if = "Option::is_none")]
9720    pub db: Option<Expression>,
9721    /// Target identifier (MySQL: engine name in SHOW ENGINE, table in SHOW COLUMNS FROM)
9722    #[serde(default, skip_serializing_if = "Option::is_none")]
9723    pub target: Option<Expression>,
9724    /// MUTEX flag for SHOW ENGINE (true=MUTEX, false=STATUS, None=neither)
9725    #[serde(default, skip_serializing_if = "Option::is_none")]
9726    pub mutex: Option<bool>,
9727    /// WITH PRIVILEGES clause (Snowflake: SHOW ... WITH PRIVILEGES USAGE, MODIFY)
9728    #[serde(default, skip_serializing_if = "Vec::is_empty")]
9729    pub privileges: Vec<String>,
9730}
9731
9732impl Show {
9733    pub fn new(this: impl Into<String>) -> Self {
9734        Self {
9735            this: this.into(),
9736            terse: false,
9737            history: false,
9738            like: None,
9739            scope_kind: None,
9740            scope: None,
9741            starts_with: None,
9742            limit: None,
9743            from: None,
9744            where_clause: None,
9745            for_target: None,
9746            db: None,
9747            target: None,
9748            mutex: None,
9749            privileges: Vec::new(),
9750        }
9751    }
9752}
9753
9754/// Represent an explicit parenthesized expression for grouping precedence.
9755///
9756/// Preserves user-written parentheses so that `(a + b) * c` round-trips
9757/// correctly instead of being flattened to `a + b * c`.
9758#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9759#[cfg_attr(feature = "bindings", derive(TS))]
9760pub struct Paren {
9761    /// The inner expression wrapped by parentheses.
9762    pub this: Expression,
9763    #[serde(default)]
9764    pub trailing_comments: Vec<String>,
9765}
9766
9767/// Expression annotated with trailing comments (for round-trip preservation)
9768#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9769#[cfg_attr(feature = "bindings", derive(TS))]
9770pub struct Annotated {
9771    pub this: Expression,
9772    pub trailing_comments: Vec<String>,
9773}
9774
9775// === BATCH GENERATED STRUCT DEFINITIONS ===
9776// Generated from Python sqlglot expressions.py
9777
9778/// Refresh
9779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9780#[cfg_attr(feature = "bindings", derive(TS))]
9781pub struct Refresh {
9782    pub this: Box<Expression>,
9783    pub kind: String,
9784}
9785
9786/// LockingStatement
9787#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9788#[cfg_attr(feature = "bindings", derive(TS))]
9789pub struct LockingStatement {
9790    pub this: Box<Expression>,
9791    pub expression: Box<Expression>,
9792}
9793
9794/// SequenceProperties
9795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9796#[cfg_attr(feature = "bindings", derive(TS))]
9797pub struct SequenceProperties {
9798    #[serde(default)]
9799    pub increment: Option<Box<Expression>>,
9800    #[serde(default)]
9801    pub minvalue: Option<Box<Expression>>,
9802    #[serde(default)]
9803    pub maxvalue: Option<Box<Expression>>,
9804    #[serde(default)]
9805    pub cache: Option<Box<Expression>>,
9806    #[serde(default)]
9807    pub start: Option<Box<Expression>>,
9808    #[serde(default)]
9809    pub owned: Option<Box<Expression>>,
9810    #[serde(default)]
9811    pub options: Vec<Expression>,
9812}
9813
9814/// TruncateTable
9815#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9816#[cfg_attr(feature = "bindings", derive(TS))]
9817pub struct TruncateTable {
9818    #[serde(default)]
9819    pub expressions: Vec<Expression>,
9820    #[serde(default)]
9821    pub is_database: Option<Box<Expression>>,
9822    #[serde(default)]
9823    pub exists: bool,
9824    #[serde(default)]
9825    pub only: Option<Box<Expression>>,
9826    #[serde(default)]
9827    pub cluster: Option<Box<Expression>>,
9828    #[serde(default)]
9829    pub identity: Option<Box<Expression>>,
9830    #[serde(default)]
9831    pub option: Option<Box<Expression>>,
9832    #[serde(default)]
9833    pub partition: Option<Box<Expression>>,
9834}
9835
9836/// Clone
9837#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9838#[cfg_attr(feature = "bindings", derive(TS))]
9839pub struct Clone {
9840    pub this: Box<Expression>,
9841    #[serde(default)]
9842    pub shallow: Option<Box<Expression>>,
9843    #[serde(default)]
9844    pub copy: Option<Box<Expression>>,
9845}
9846
9847/// Attach
9848#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9849#[cfg_attr(feature = "bindings", derive(TS))]
9850pub struct Attach {
9851    pub this: Box<Expression>,
9852    #[serde(default)]
9853    pub exists: bool,
9854    #[serde(default)]
9855    pub expressions: Vec<Expression>,
9856}
9857
9858/// Detach
9859#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9860#[cfg_attr(feature = "bindings", derive(TS))]
9861pub struct Detach {
9862    pub this: Box<Expression>,
9863    #[serde(default)]
9864    pub exists: bool,
9865}
9866
9867/// Install
9868#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9869#[cfg_attr(feature = "bindings", derive(TS))]
9870pub struct Install {
9871    pub this: Box<Expression>,
9872    #[serde(default)]
9873    pub from_: Option<Box<Expression>>,
9874    #[serde(default)]
9875    pub force: Option<Box<Expression>>,
9876}
9877
9878/// Summarize
9879#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9880#[cfg_attr(feature = "bindings", derive(TS))]
9881pub struct Summarize {
9882    pub this: Box<Expression>,
9883    #[serde(default)]
9884    pub table: Option<Box<Expression>>,
9885}
9886
9887/// Declare
9888#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9889#[cfg_attr(feature = "bindings", derive(TS))]
9890pub struct Declare {
9891    #[serde(default)]
9892    pub expressions: Vec<Expression>,
9893    #[serde(default)]
9894    pub replace: bool,
9895}
9896
9897/// DeclareItem
9898#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9899#[cfg_attr(feature = "bindings", derive(TS))]
9900pub struct DeclareItem {
9901    pub this: Box<Expression>,
9902    #[serde(default)]
9903    pub kind: Option<String>,
9904    #[serde(default)]
9905    pub default: Option<Box<Expression>>,
9906    #[serde(default)]
9907    pub has_as: bool,
9908    /// BigQuery: additional variable names in multi-variable DECLARE (DECLARE X, Y, Z INT64)
9909    #[serde(default, skip_serializing_if = "Vec::is_empty")]
9910    pub additional_names: Vec<Expression>,
9911}
9912
9913/// Set
9914#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9915#[cfg_attr(feature = "bindings", derive(TS))]
9916pub struct Set {
9917    #[serde(default)]
9918    pub expressions: Vec<Expression>,
9919    #[serde(default)]
9920    pub unset: Option<Box<Expression>>,
9921    #[serde(default)]
9922    pub tag: Option<Box<Expression>>,
9923}
9924
9925/// Heredoc
9926#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9927#[cfg_attr(feature = "bindings", derive(TS))]
9928pub struct Heredoc {
9929    pub this: Box<Expression>,
9930    #[serde(default)]
9931    pub tag: Option<Box<Expression>>,
9932}
9933
9934/// QueryBand
9935#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9936#[cfg_attr(feature = "bindings", derive(TS))]
9937pub struct QueryBand {
9938    pub this: Box<Expression>,
9939    #[serde(default)]
9940    pub scope: Option<Box<Expression>>,
9941    #[serde(default)]
9942    pub update: Option<Box<Expression>>,
9943}
9944
9945/// UserDefinedFunction
9946#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9947#[cfg_attr(feature = "bindings", derive(TS))]
9948pub struct UserDefinedFunction {
9949    pub this: Box<Expression>,
9950    #[serde(default)]
9951    pub expressions: Vec<Expression>,
9952    #[serde(default)]
9953    pub wrapped: Option<Box<Expression>>,
9954}
9955
9956/// RecursiveWithSearch
9957#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9958#[cfg_attr(feature = "bindings", derive(TS))]
9959pub struct RecursiveWithSearch {
9960    pub kind: String,
9961    pub this: Box<Expression>,
9962    pub expression: Box<Expression>,
9963    #[serde(default)]
9964    pub using: Option<Box<Expression>>,
9965}
9966
9967/// ProjectionDef
9968#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9969#[cfg_attr(feature = "bindings", derive(TS))]
9970pub struct ProjectionDef {
9971    pub this: Box<Expression>,
9972    pub expression: Box<Expression>,
9973}
9974
9975/// TableAlias
9976#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9977#[cfg_attr(feature = "bindings", derive(TS))]
9978pub struct TableAlias {
9979    #[serde(default)]
9980    pub this: Option<Box<Expression>>,
9981    #[serde(default)]
9982    pub columns: Vec<Expression>,
9983}
9984
9985/// ByteString
9986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9987#[cfg_attr(feature = "bindings", derive(TS))]
9988pub struct ByteString {
9989    pub this: Box<Expression>,
9990    #[serde(default)]
9991    pub is_bytes: Option<Box<Expression>>,
9992}
9993
9994/// HexStringExpr - Hex string expression (not literal)
9995/// BigQuery: converts to FROM_HEX(this)
9996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9997#[cfg_attr(feature = "bindings", derive(TS))]
9998pub struct HexStringExpr {
9999    pub this: Box<Expression>,
10000    #[serde(default)]
10001    pub is_integer: Option<bool>,
10002}
10003
10004/// UnicodeString
10005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10006#[cfg_attr(feature = "bindings", derive(TS))]
10007pub struct UnicodeString {
10008    pub this: Box<Expression>,
10009    #[serde(default)]
10010    pub escape: Option<Box<Expression>>,
10011}
10012
10013/// AlterColumn
10014#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10015#[cfg_attr(feature = "bindings", derive(TS))]
10016pub struct AlterColumn {
10017    pub this: Box<Expression>,
10018    #[serde(default)]
10019    pub dtype: Option<Box<Expression>>,
10020    #[serde(default)]
10021    pub collate: Option<Box<Expression>>,
10022    #[serde(default)]
10023    pub using: Option<Box<Expression>>,
10024    #[serde(default)]
10025    pub default: Option<Box<Expression>>,
10026    #[serde(default)]
10027    pub drop: Option<Box<Expression>>,
10028    #[serde(default)]
10029    pub comment: Option<Box<Expression>>,
10030    #[serde(default)]
10031    pub allow_null: Option<Box<Expression>>,
10032    #[serde(default)]
10033    pub visible: Option<Box<Expression>>,
10034    #[serde(default)]
10035    pub rename_to: Option<Box<Expression>>,
10036}
10037
10038/// AlterSortKey
10039#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10040#[cfg_attr(feature = "bindings", derive(TS))]
10041pub struct AlterSortKey {
10042    #[serde(default)]
10043    pub this: Option<Box<Expression>>,
10044    #[serde(default)]
10045    pub expressions: Vec<Expression>,
10046    #[serde(default)]
10047    pub compound: Option<Box<Expression>>,
10048}
10049
10050/// AlterSet
10051#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10052#[cfg_attr(feature = "bindings", derive(TS))]
10053pub struct AlterSet {
10054    #[serde(default)]
10055    pub expressions: Vec<Expression>,
10056    #[serde(default)]
10057    pub option: Option<Box<Expression>>,
10058    #[serde(default)]
10059    pub tablespace: Option<Box<Expression>>,
10060    #[serde(default)]
10061    pub access_method: Option<Box<Expression>>,
10062    #[serde(default)]
10063    pub file_format: Option<Box<Expression>>,
10064    #[serde(default)]
10065    pub copy_options: Option<Box<Expression>>,
10066    #[serde(default)]
10067    pub tag: Option<Box<Expression>>,
10068    #[serde(default)]
10069    pub location: Option<Box<Expression>>,
10070    #[serde(default)]
10071    pub serde: Option<Box<Expression>>,
10072}
10073
10074/// RenameColumn
10075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10076#[cfg_attr(feature = "bindings", derive(TS))]
10077pub struct RenameColumn {
10078    pub this: Box<Expression>,
10079    #[serde(default)]
10080    pub to: Option<Box<Expression>>,
10081    #[serde(default)]
10082    pub exists: bool,
10083}
10084
10085/// Comprehension
10086#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10087#[cfg_attr(feature = "bindings", derive(TS))]
10088pub struct Comprehension {
10089    pub this: Box<Expression>,
10090    pub expression: Box<Expression>,
10091    #[serde(default)]
10092    pub position: Option<Box<Expression>>,
10093    #[serde(default)]
10094    pub iterator: Option<Box<Expression>>,
10095    #[serde(default)]
10096    pub condition: Option<Box<Expression>>,
10097}
10098
10099/// MergeTreeTTLAction
10100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10101#[cfg_attr(feature = "bindings", derive(TS))]
10102pub struct MergeTreeTTLAction {
10103    pub this: Box<Expression>,
10104    #[serde(default)]
10105    pub delete: Option<Box<Expression>>,
10106    #[serde(default)]
10107    pub recompress: Option<Box<Expression>>,
10108    #[serde(default)]
10109    pub to_disk: Option<Box<Expression>>,
10110    #[serde(default)]
10111    pub to_volume: Option<Box<Expression>>,
10112}
10113
10114/// MergeTreeTTL
10115#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10116#[cfg_attr(feature = "bindings", derive(TS))]
10117pub struct MergeTreeTTL {
10118    #[serde(default)]
10119    pub expressions: Vec<Expression>,
10120    #[serde(default)]
10121    pub where_: Option<Box<Expression>>,
10122    #[serde(default)]
10123    pub group: Option<Box<Expression>>,
10124    #[serde(default)]
10125    pub aggregates: Option<Box<Expression>>,
10126}
10127
10128/// IndexConstraintOption
10129#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10130#[cfg_attr(feature = "bindings", derive(TS))]
10131pub struct IndexConstraintOption {
10132    #[serde(default)]
10133    pub key_block_size: Option<Box<Expression>>,
10134    #[serde(default)]
10135    pub using: Option<Box<Expression>>,
10136    #[serde(default)]
10137    pub parser: Option<Box<Expression>>,
10138    #[serde(default)]
10139    pub comment: Option<Box<Expression>>,
10140    #[serde(default)]
10141    pub visible: Option<Box<Expression>>,
10142    #[serde(default)]
10143    pub engine_attr: Option<Box<Expression>>,
10144    #[serde(default)]
10145    pub secondary_engine_attr: Option<Box<Expression>>,
10146}
10147
10148/// PeriodForSystemTimeConstraint
10149#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10150#[cfg_attr(feature = "bindings", derive(TS))]
10151pub struct PeriodForSystemTimeConstraint {
10152    pub this: Box<Expression>,
10153    pub expression: Box<Expression>,
10154}
10155
10156/// CaseSpecificColumnConstraint
10157#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10158#[cfg_attr(feature = "bindings", derive(TS))]
10159pub struct CaseSpecificColumnConstraint {
10160    #[serde(default)]
10161    pub not_: Option<Box<Expression>>,
10162}
10163
10164/// CharacterSetColumnConstraint
10165#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10166#[cfg_attr(feature = "bindings", derive(TS))]
10167pub struct CharacterSetColumnConstraint {
10168    pub this: Box<Expression>,
10169}
10170
10171/// CheckColumnConstraint
10172#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10173#[cfg_attr(feature = "bindings", derive(TS))]
10174pub struct CheckColumnConstraint {
10175    pub this: Box<Expression>,
10176    #[serde(default)]
10177    pub enforced: Option<Box<Expression>>,
10178}
10179
10180/// AssumeColumnConstraint (ClickHouse ASSUME constraint)
10181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10182#[cfg_attr(feature = "bindings", derive(TS))]
10183pub struct AssumeColumnConstraint {
10184    pub this: Box<Expression>,
10185}
10186
10187/// CompressColumnConstraint
10188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10189#[cfg_attr(feature = "bindings", derive(TS))]
10190pub struct CompressColumnConstraint {
10191    #[serde(default)]
10192    pub this: Option<Box<Expression>>,
10193}
10194
10195/// DateFormatColumnConstraint
10196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10197#[cfg_attr(feature = "bindings", derive(TS))]
10198pub struct DateFormatColumnConstraint {
10199    pub this: Box<Expression>,
10200}
10201
10202/// EphemeralColumnConstraint
10203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10204#[cfg_attr(feature = "bindings", derive(TS))]
10205pub struct EphemeralColumnConstraint {
10206    #[serde(default)]
10207    pub this: Option<Box<Expression>>,
10208}
10209
10210/// WithOperator
10211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10212#[cfg_attr(feature = "bindings", derive(TS))]
10213pub struct WithOperator {
10214    pub this: Box<Expression>,
10215    pub op: String,
10216}
10217
10218/// GeneratedAsIdentityColumnConstraint
10219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10220#[cfg_attr(feature = "bindings", derive(TS))]
10221pub struct GeneratedAsIdentityColumnConstraint {
10222    #[serde(default)]
10223    pub this: Option<Box<Expression>>,
10224    #[serde(default)]
10225    pub expression: Option<Box<Expression>>,
10226    #[serde(default)]
10227    pub on_null: Option<Box<Expression>>,
10228    #[serde(default)]
10229    pub start: Option<Box<Expression>>,
10230    #[serde(default)]
10231    pub increment: Option<Box<Expression>>,
10232    #[serde(default)]
10233    pub minvalue: Option<Box<Expression>>,
10234    #[serde(default)]
10235    pub maxvalue: Option<Box<Expression>>,
10236    #[serde(default)]
10237    pub cycle: Option<Box<Expression>>,
10238    #[serde(default)]
10239    pub order: Option<Box<Expression>>,
10240}
10241
10242/// AutoIncrementColumnConstraint - MySQL/TSQL auto-increment marker
10243/// TSQL: outputs "IDENTITY"
10244#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10245#[cfg_attr(feature = "bindings", derive(TS))]
10246pub struct AutoIncrementColumnConstraint;
10247
10248/// CommentColumnConstraint - Column comment marker
10249#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10250#[cfg_attr(feature = "bindings", derive(TS))]
10251pub struct CommentColumnConstraint;
10252
10253/// GeneratedAsRowColumnConstraint
10254#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10255#[cfg_attr(feature = "bindings", derive(TS))]
10256pub struct GeneratedAsRowColumnConstraint {
10257    #[serde(default)]
10258    pub start: Option<Box<Expression>>,
10259    #[serde(default)]
10260    pub hidden: Option<Box<Expression>>,
10261}
10262
10263/// IndexColumnConstraint
10264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10265#[cfg_attr(feature = "bindings", derive(TS))]
10266pub struct IndexColumnConstraint {
10267    #[serde(default)]
10268    pub this: Option<Box<Expression>>,
10269    #[serde(default)]
10270    pub expressions: Vec<Expression>,
10271    #[serde(default)]
10272    pub kind: Option<String>,
10273    #[serde(default)]
10274    pub index_type: Option<Box<Expression>>,
10275    #[serde(default)]
10276    pub options: Vec<Expression>,
10277    #[serde(default)]
10278    pub expression: Option<Box<Expression>>,
10279    #[serde(default)]
10280    pub granularity: Option<Box<Expression>>,
10281}
10282
10283/// MaskingPolicyColumnConstraint
10284#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10285#[cfg_attr(feature = "bindings", derive(TS))]
10286pub struct MaskingPolicyColumnConstraint {
10287    pub this: Box<Expression>,
10288    #[serde(default)]
10289    pub expressions: Vec<Expression>,
10290}
10291
10292/// NotNullColumnConstraint
10293#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10294#[cfg_attr(feature = "bindings", derive(TS))]
10295pub struct NotNullColumnConstraint {
10296    #[serde(default)]
10297    pub allow_null: Option<Box<Expression>>,
10298}
10299
10300/// DefaultColumnConstraint - DEFAULT value for a column
10301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10302#[cfg_attr(feature = "bindings", derive(TS))]
10303pub struct DefaultColumnConstraint {
10304    pub this: Box<Expression>,
10305    /// TSQL: DEFAULT value FOR column (table-level default constraint)
10306    #[serde(default, skip_serializing_if = "Option::is_none")]
10307    pub for_column: Option<Identifier>,
10308}
10309
10310/// PrimaryKeyColumnConstraint
10311#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10312#[cfg_attr(feature = "bindings", derive(TS))]
10313pub struct PrimaryKeyColumnConstraint {
10314    #[serde(default)]
10315    pub desc: Option<Box<Expression>>,
10316    #[serde(default)]
10317    pub options: Vec<Expression>,
10318}
10319
10320/// UniqueColumnConstraint
10321#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10322#[cfg_attr(feature = "bindings", derive(TS))]
10323pub struct UniqueColumnConstraint {
10324    #[serde(default)]
10325    pub this: Option<Box<Expression>>,
10326    #[serde(default)]
10327    pub index_type: Option<Box<Expression>>,
10328    #[serde(default)]
10329    pub on_conflict: Option<Box<Expression>>,
10330    #[serde(default)]
10331    pub nulls: Option<Box<Expression>>,
10332    #[serde(default)]
10333    pub options: Vec<Expression>,
10334}
10335
10336/// WatermarkColumnConstraint
10337#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10338#[cfg_attr(feature = "bindings", derive(TS))]
10339pub struct WatermarkColumnConstraint {
10340    pub this: Box<Expression>,
10341    pub expression: Box<Expression>,
10342}
10343
10344/// ComputedColumnConstraint
10345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10346#[cfg_attr(feature = "bindings", derive(TS))]
10347pub struct ComputedColumnConstraint {
10348    pub this: Box<Expression>,
10349    #[serde(default)]
10350    pub persisted: Option<Box<Expression>>,
10351    #[serde(default)]
10352    pub not_null: Option<Box<Expression>>,
10353    #[serde(default)]
10354    pub data_type: Option<Box<Expression>>,
10355}
10356
10357/// InOutColumnConstraint
10358#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10359#[cfg_attr(feature = "bindings", derive(TS))]
10360pub struct InOutColumnConstraint {
10361    #[serde(default)]
10362    pub input_: Option<Box<Expression>>,
10363    #[serde(default)]
10364    pub output: Option<Box<Expression>>,
10365}
10366
10367/// PathColumnConstraint - PATH 'xpath' for XMLTABLE/JSON_TABLE columns
10368#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10369#[cfg_attr(feature = "bindings", derive(TS))]
10370pub struct PathColumnConstraint {
10371    pub this: Box<Expression>,
10372}
10373
10374/// Constraint
10375#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10376#[cfg_attr(feature = "bindings", derive(TS))]
10377pub struct Constraint {
10378    pub this: Box<Expression>,
10379    #[serde(default)]
10380    pub expressions: Vec<Expression>,
10381}
10382
10383/// Export
10384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10385#[cfg_attr(feature = "bindings", derive(TS))]
10386pub struct Export {
10387    pub this: Box<Expression>,
10388    #[serde(default)]
10389    pub connection: Option<Box<Expression>>,
10390    #[serde(default)]
10391    pub options: Vec<Expression>,
10392}
10393
10394/// Filter
10395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10396#[cfg_attr(feature = "bindings", derive(TS))]
10397pub struct Filter {
10398    pub this: Box<Expression>,
10399    pub expression: Box<Expression>,
10400}
10401
10402/// Changes
10403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10404#[cfg_attr(feature = "bindings", derive(TS))]
10405pub struct Changes {
10406    #[serde(default)]
10407    pub information: Option<Box<Expression>>,
10408    #[serde(default)]
10409    pub at_before: Option<Box<Expression>>,
10410    #[serde(default)]
10411    pub end: Option<Box<Expression>>,
10412}
10413
10414/// Directory
10415#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10416#[cfg_attr(feature = "bindings", derive(TS))]
10417pub struct Directory {
10418    pub this: Box<Expression>,
10419    #[serde(default)]
10420    pub local: Option<Box<Expression>>,
10421    #[serde(default)]
10422    pub row_format: Option<Box<Expression>>,
10423}
10424
10425/// ForeignKey
10426#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10427#[cfg_attr(feature = "bindings", derive(TS))]
10428pub struct ForeignKey {
10429    #[serde(default)]
10430    pub expressions: Vec<Expression>,
10431    #[serde(default)]
10432    pub reference: Option<Box<Expression>>,
10433    #[serde(default)]
10434    pub delete: Option<Box<Expression>>,
10435    #[serde(default)]
10436    pub update: Option<Box<Expression>>,
10437    #[serde(default)]
10438    pub options: Vec<Expression>,
10439}
10440
10441/// ColumnPrefix
10442#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10443#[cfg_attr(feature = "bindings", derive(TS))]
10444pub struct ColumnPrefix {
10445    pub this: Box<Expression>,
10446    pub expression: Box<Expression>,
10447}
10448
10449/// PrimaryKey
10450#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10451#[cfg_attr(feature = "bindings", derive(TS))]
10452pub struct PrimaryKey {
10453    #[serde(default)]
10454    pub this: Option<Box<Expression>>,
10455    #[serde(default)]
10456    pub expressions: Vec<Expression>,
10457    #[serde(default)]
10458    pub options: Vec<Expression>,
10459    #[serde(default)]
10460    pub include: Option<Box<Expression>>,
10461}
10462
10463/// Into
10464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10465#[cfg_attr(feature = "bindings", derive(TS))]
10466pub struct IntoClause {
10467    #[serde(default)]
10468    pub this: Option<Box<Expression>>,
10469    #[serde(default)]
10470    pub temporary: bool,
10471    #[serde(default)]
10472    pub unlogged: Option<Box<Expression>>,
10473    #[serde(default)]
10474    pub bulk_collect: Option<Box<Expression>>,
10475    #[serde(default)]
10476    pub expressions: Vec<Expression>,
10477}
10478
10479/// JoinHint
10480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10481#[cfg_attr(feature = "bindings", derive(TS))]
10482pub struct JoinHint {
10483    pub this: Box<Expression>,
10484    #[serde(default)]
10485    pub expressions: Vec<Expression>,
10486}
10487
10488/// Opclass
10489#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10490#[cfg_attr(feature = "bindings", derive(TS))]
10491pub struct Opclass {
10492    pub this: Box<Expression>,
10493    pub expression: Box<Expression>,
10494}
10495
10496/// Index
10497#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10498#[cfg_attr(feature = "bindings", derive(TS))]
10499pub struct Index {
10500    #[serde(default)]
10501    pub this: Option<Box<Expression>>,
10502    #[serde(default)]
10503    pub table: Option<Box<Expression>>,
10504    #[serde(default)]
10505    pub unique: bool,
10506    #[serde(default)]
10507    pub primary: Option<Box<Expression>>,
10508    #[serde(default)]
10509    pub amp: Option<Box<Expression>>,
10510    #[serde(default)]
10511    pub params: Vec<Expression>,
10512}
10513
10514/// IndexParameters
10515#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10516#[cfg_attr(feature = "bindings", derive(TS))]
10517pub struct IndexParameters {
10518    #[serde(default)]
10519    pub using: Option<Box<Expression>>,
10520    #[serde(default)]
10521    pub include: Option<Box<Expression>>,
10522    #[serde(default)]
10523    pub columns: Vec<Expression>,
10524    #[serde(default)]
10525    pub with_storage: Option<Box<Expression>>,
10526    #[serde(default)]
10527    pub partition_by: Option<Box<Expression>>,
10528    #[serde(default)]
10529    pub tablespace: Option<Box<Expression>>,
10530    #[serde(default)]
10531    pub where_: Option<Box<Expression>>,
10532    #[serde(default)]
10533    pub on: Option<Box<Expression>>,
10534}
10535
10536/// ConditionalInsert
10537#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10538#[cfg_attr(feature = "bindings", derive(TS))]
10539pub struct ConditionalInsert {
10540    pub this: Box<Expression>,
10541    #[serde(default)]
10542    pub expression: Option<Box<Expression>>,
10543    #[serde(default)]
10544    pub else_: Option<Box<Expression>>,
10545}
10546
10547/// MultitableInserts
10548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10549#[cfg_attr(feature = "bindings", derive(TS))]
10550pub struct MultitableInserts {
10551    #[serde(default)]
10552    pub expressions: Vec<Expression>,
10553    pub kind: String,
10554    #[serde(default)]
10555    pub source: Option<Box<Expression>>,
10556    /// Leading comments before the statement
10557    #[serde(default)]
10558    pub leading_comments: Vec<String>,
10559}
10560
10561/// OnConflict
10562#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10563#[cfg_attr(feature = "bindings", derive(TS))]
10564pub struct OnConflict {
10565    #[serde(default)]
10566    pub duplicate: Option<Box<Expression>>,
10567    #[serde(default)]
10568    pub expressions: Vec<Expression>,
10569    #[serde(default)]
10570    pub action: Option<Box<Expression>>,
10571    #[serde(default)]
10572    pub conflict_keys: Option<Box<Expression>>,
10573    #[serde(default)]
10574    pub index_predicate: Option<Box<Expression>>,
10575    #[serde(default)]
10576    pub constraint: Option<Box<Expression>>,
10577    #[serde(default)]
10578    pub where_: Option<Box<Expression>>,
10579}
10580
10581/// OnCondition
10582#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10583#[cfg_attr(feature = "bindings", derive(TS))]
10584pub struct OnCondition {
10585    #[serde(default)]
10586    pub error: Option<Box<Expression>>,
10587    #[serde(default)]
10588    pub empty: Option<Box<Expression>>,
10589    #[serde(default)]
10590    pub null: Option<Box<Expression>>,
10591}
10592
10593/// Returning
10594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10595#[cfg_attr(feature = "bindings", derive(TS))]
10596pub struct Returning {
10597    #[serde(default)]
10598    pub expressions: Vec<Expression>,
10599    #[serde(default)]
10600    pub into: Option<Box<Expression>>,
10601}
10602
10603/// Introducer
10604#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10605#[cfg_attr(feature = "bindings", derive(TS))]
10606pub struct Introducer {
10607    pub this: Box<Expression>,
10608    pub expression: Box<Expression>,
10609}
10610
10611/// PartitionRange
10612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10613#[cfg_attr(feature = "bindings", derive(TS))]
10614pub struct PartitionRange {
10615    pub this: Box<Expression>,
10616    #[serde(default)]
10617    pub expression: Option<Box<Expression>>,
10618    #[serde(default)]
10619    pub expressions: Vec<Expression>,
10620}
10621
10622/// Group
10623#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10624#[cfg_attr(feature = "bindings", derive(TS))]
10625pub struct Group {
10626    #[serde(default)]
10627    pub expressions: Vec<Expression>,
10628    #[serde(default)]
10629    pub grouping_sets: Option<Box<Expression>>,
10630    #[serde(default)]
10631    pub cube: Option<Box<Expression>>,
10632    #[serde(default)]
10633    pub rollup: Option<Box<Expression>>,
10634    #[serde(default)]
10635    pub totals: Option<Box<Expression>>,
10636    /// GROUP BY modifier: Some(true) = ALL, Some(false) = DISTINCT, None = no modifier
10637    #[serde(default)]
10638    pub all: Option<bool>,
10639}
10640
10641/// Cube
10642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10643#[cfg_attr(feature = "bindings", derive(TS))]
10644pub struct Cube {
10645    #[serde(default)]
10646    pub expressions: Vec<Expression>,
10647}
10648
10649/// Rollup
10650#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10651#[cfg_attr(feature = "bindings", derive(TS))]
10652pub struct Rollup {
10653    #[serde(default)]
10654    pub expressions: Vec<Expression>,
10655}
10656
10657/// GroupingSets
10658#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10659#[cfg_attr(feature = "bindings", derive(TS))]
10660pub struct GroupingSets {
10661    #[serde(default)]
10662    pub expressions: Vec<Expression>,
10663}
10664
10665/// LimitOptions
10666#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10667#[cfg_attr(feature = "bindings", derive(TS))]
10668pub struct LimitOptions {
10669    #[serde(default)]
10670    pub percent: Option<Box<Expression>>,
10671    #[serde(default)]
10672    pub rows: Option<Box<Expression>>,
10673    #[serde(default)]
10674    pub with_ties: Option<Box<Expression>>,
10675}
10676
10677/// Lateral
10678#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10679#[cfg_attr(feature = "bindings", derive(TS))]
10680pub struct Lateral {
10681    pub this: Box<Expression>,
10682    #[serde(default)]
10683    pub view: Option<Box<Expression>>,
10684    #[serde(default)]
10685    pub outer: Option<Box<Expression>>,
10686    #[serde(default)]
10687    pub alias: Option<String>,
10688    /// Whether the alias was originally quoted (backtick/double-quote)
10689    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
10690    pub alias_quoted: bool,
10691    #[serde(default)]
10692    pub cross_apply: Option<Box<Expression>>,
10693    #[serde(default)]
10694    pub ordinality: Option<Box<Expression>>,
10695    /// Column aliases for the lateral expression (e.g., LATERAL func() AS alias(col1, col2))
10696    #[serde(default, skip_serializing_if = "Vec::is_empty")]
10697    pub column_aliases: Vec<String>,
10698}
10699
10700/// TableFromRows
10701#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10702#[cfg_attr(feature = "bindings", derive(TS))]
10703pub struct TableFromRows {
10704    pub this: Box<Expression>,
10705    #[serde(default)]
10706    pub alias: Option<String>,
10707    #[serde(default)]
10708    pub joins: Vec<Expression>,
10709    #[serde(default)]
10710    pub pivots: Option<Box<Expression>>,
10711    #[serde(default)]
10712    pub sample: Option<Box<Expression>>,
10713}
10714
10715/// RowsFrom - PostgreSQL ROWS FROM (func1(args) AS alias1(...), func2(args) AS alias2(...)) syntax
10716/// Used for set-returning functions with typed column definitions
10717#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10718#[cfg_attr(feature = "bindings", derive(TS))]
10719pub struct RowsFrom {
10720    /// List of function expressions, each potentially with an alias and typed columns
10721    pub expressions: Vec<Expression>,
10722    /// WITH ORDINALITY modifier
10723    #[serde(default)]
10724    pub ordinality: bool,
10725    /// Optional outer alias: ROWS FROM (...) AS alias(col1 type1, col2 type2)
10726    #[serde(default)]
10727    pub alias: Option<Box<Expression>>,
10728}
10729
10730/// WithFill
10731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10732#[cfg_attr(feature = "bindings", derive(TS))]
10733pub struct WithFill {
10734    #[serde(default)]
10735    pub from_: Option<Box<Expression>>,
10736    #[serde(default)]
10737    pub to: Option<Box<Expression>>,
10738    #[serde(default)]
10739    pub step: Option<Box<Expression>>,
10740    #[serde(default)]
10741    pub staleness: Option<Box<Expression>>,
10742    #[serde(default)]
10743    pub interpolate: Option<Box<Expression>>,
10744}
10745
10746/// Property
10747#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10748#[cfg_attr(feature = "bindings", derive(TS))]
10749pub struct Property {
10750    pub this: Box<Expression>,
10751    #[serde(default)]
10752    pub value: Option<Box<Expression>>,
10753}
10754
10755/// GrantPrivilege
10756#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10757#[cfg_attr(feature = "bindings", derive(TS))]
10758pub struct GrantPrivilege {
10759    pub this: Box<Expression>,
10760    #[serde(default)]
10761    pub expressions: Vec<Expression>,
10762}
10763
10764/// AllowedValuesProperty
10765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10766#[cfg_attr(feature = "bindings", derive(TS))]
10767pub struct AllowedValuesProperty {
10768    #[serde(default)]
10769    pub expressions: Vec<Expression>,
10770}
10771
10772/// AlgorithmProperty
10773#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10774#[cfg_attr(feature = "bindings", derive(TS))]
10775pub struct AlgorithmProperty {
10776    pub this: Box<Expression>,
10777}
10778
10779/// AutoIncrementProperty
10780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10781#[cfg_attr(feature = "bindings", derive(TS))]
10782pub struct AutoIncrementProperty {
10783    pub this: Box<Expression>,
10784}
10785
10786/// AutoRefreshProperty
10787#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10788#[cfg_attr(feature = "bindings", derive(TS))]
10789pub struct AutoRefreshProperty {
10790    pub this: Box<Expression>,
10791}
10792
10793/// BackupProperty
10794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10795#[cfg_attr(feature = "bindings", derive(TS))]
10796pub struct BackupProperty {
10797    pub this: Box<Expression>,
10798}
10799
10800/// BuildProperty
10801#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10802#[cfg_attr(feature = "bindings", derive(TS))]
10803pub struct BuildProperty {
10804    pub this: Box<Expression>,
10805}
10806
10807/// BlockCompressionProperty
10808#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10809#[cfg_attr(feature = "bindings", derive(TS))]
10810pub struct BlockCompressionProperty {
10811    #[serde(default)]
10812    pub autotemp: Option<Box<Expression>>,
10813    #[serde(default)]
10814    pub always: Option<Box<Expression>>,
10815    #[serde(default)]
10816    pub default: Option<Box<Expression>>,
10817    #[serde(default)]
10818    pub manual: Option<Box<Expression>>,
10819    #[serde(default)]
10820    pub never: Option<Box<Expression>>,
10821}
10822
10823/// CharacterSetProperty
10824#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10825#[cfg_attr(feature = "bindings", derive(TS))]
10826pub struct CharacterSetProperty {
10827    pub this: Box<Expression>,
10828    #[serde(default)]
10829    pub default: Option<Box<Expression>>,
10830}
10831
10832/// ChecksumProperty
10833#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10834#[cfg_attr(feature = "bindings", derive(TS))]
10835pub struct ChecksumProperty {
10836    #[serde(default)]
10837    pub on: Option<Box<Expression>>,
10838    #[serde(default)]
10839    pub default: Option<Box<Expression>>,
10840}
10841
10842/// CollateProperty
10843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10844#[cfg_attr(feature = "bindings", derive(TS))]
10845pub struct CollateProperty {
10846    pub this: Box<Expression>,
10847    #[serde(default)]
10848    pub default: Option<Box<Expression>>,
10849}
10850
10851/// DataBlocksizeProperty
10852#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10853#[cfg_attr(feature = "bindings", derive(TS))]
10854pub struct DataBlocksizeProperty {
10855    #[serde(default)]
10856    pub size: Option<i64>,
10857    #[serde(default)]
10858    pub units: Option<Box<Expression>>,
10859    #[serde(default)]
10860    pub minimum: Option<Box<Expression>>,
10861    #[serde(default)]
10862    pub maximum: Option<Box<Expression>>,
10863    #[serde(default)]
10864    pub default: Option<Box<Expression>>,
10865}
10866
10867/// DataDeletionProperty
10868#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10869#[cfg_attr(feature = "bindings", derive(TS))]
10870pub struct DataDeletionProperty {
10871    pub on: Box<Expression>,
10872    #[serde(default)]
10873    pub filter_column: Option<Box<Expression>>,
10874    #[serde(default)]
10875    pub retention_period: Option<Box<Expression>>,
10876}
10877
10878/// DefinerProperty
10879#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10880#[cfg_attr(feature = "bindings", derive(TS))]
10881pub struct DefinerProperty {
10882    pub this: Box<Expression>,
10883}
10884
10885/// DistKeyProperty
10886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10887#[cfg_attr(feature = "bindings", derive(TS))]
10888pub struct DistKeyProperty {
10889    pub this: Box<Expression>,
10890}
10891
10892/// DistributedByProperty
10893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10894#[cfg_attr(feature = "bindings", derive(TS))]
10895pub struct DistributedByProperty {
10896    #[serde(default)]
10897    pub expressions: Vec<Expression>,
10898    pub kind: String,
10899    #[serde(default)]
10900    pub buckets: Option<Box<Expression>>,
10901    #[serde(default)]
10902    pub order: Option<Box<Expression>>,
10903}
10904
10905/// DistStyleProperty
10906#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10907#[cfg_attr(feature = "bindings", derive(TS))]
10908pub struct DistStyleProperty {
10909    pub this: Box<Expression>,
10910}
10911
10912/// DuplicateKeyProperty
10913#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10914#[cfg_attr(feature = "bindings", derive(TS))]
10915pub struct DuplicateKeyProperty {
10916    #[serde(default)]
10917    pub expressions: Vec<Expression>,
10918}
10919
10920/// EngineProperty
10921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10922#[cfg_attr(feature = "bindings", derive(TS))]
10923pub struct EngineProperty {
10924    pub this: Box<Expression>,
10925}
10926
10927/// ToTableProperty
10928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10929#[cfg_attr(feature = "bindings", derive(TS))]
10930pub struct ToTableProperty {
10931    pub this: Box<Expression>,
10932}
10933
10934/// ExecuteAsProperty
10935#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10936#[cfg_attr(feature = "bindings", derive(TS))]
10937pub struct ExecuteAsProperty {
10938    pub this: Box<Expression>,
10939}
10940
10941/// ExternalProperty
10942#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10943#[cfg_attr(feature = "bindings", derive(TS))]
10944pub struct ExternalProperty {
10945    #[serde(default)]
10946    pub this: Option<Box<Expression>>,
10947}
10948
10949/// FallbackProperty
10950#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10951#[cfg_attr(feature = "bindings", derive(TS))]
10952pub struct FallbackProperty {
10953    #[serde(default)]
10954    pub no: Option<Box<Expression>>,
10955    #[serde(default)]
10956    pub protection: Option<Box<Expression>>,
10957}
10958
10959/// FileFormatProperty
10960#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10961#[cfg_attr(feature = "bindings", derive(TS))]
10962pub struct FileFormatProperty {
10963    #[serde(default)]
10964    pub this: Option<Box<Expression>>,
10965    #[serde(default)]
10966    pub expressions: Vec<Expression>,
10967    #[serde(default)]
10968    pub hive_format: Option<Box<Expression>>,
10969}
10970
10971/// CredentialsProperty
10972#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10973#[cfg_attr(feature = "bindings", derive(TS))]
10974pub struct CredentialsProperty {
10975    #[serde(default)]
10976    pub expressions: Vec<Expression>,
10977}
10978
10979/// FreespaceProperty
10980#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10981#[cfg_attr(feature = "bindings", derive(TS))]
10982pub struct FreespaceProperty {
10983    pub this: Box<Expression>,
10984    #[serde(default)]
10985    pub percent: Option<Box<Expression>>,
10986}
10987
10988/// InheritsProperty
10989#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10990#[cfg_attr(feature = "bindings", derive(TS))]
10991pub struct InheritsProperty {
10992    #[serde(default)]
10993    pub expressions: Vec<Expression>,
10994}
10995
10996/// InputModelProperty
10997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10998#[cfg_attr(feature = "bindings", derive(TS))]
10999pub struct InputModelProperty {
11000    pub this: Box<Expression>,
11001}
11002
11003/// OutputModelProperty
11004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11005#[cfg_attr(feature = "bindings", derive(TS))]
11006pub struct OutputModelProperty {
11007    pub this: Box<Expression>,
11008}
11009
11010/// IsolatedLoadingProperty
11011#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11012#[cfg_attr(feature = "bindings", derive(TS))]
11013pub struct IsolatedLoadingProperty {
11014    #[serde(default)]
11015    pub no: Option<Box<Expression>>,
11016    #[serde(default)]
11017    pub concurrent: Option<Box<Expression>>,
11018    #[serde(default)]
11019    pub target: Option<Box<Expression>>,
11020}
11021
11022/// JournalProperty
11023#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11024#[cfg_attr(feature = "bindings", derive(TS))]
11025pub struct JournalProperty {
11026    #[serde(default)]
11027    pub no: Option<Box<Expression>>,
11028    #[serde(default)]
11029    pub dual: Option<Box<Expression>>,
11030    #[serde(default)]
11031    pub before: Option<Box<Expression>>,
11032    #[serde(default)]
11033    pub local: Option<Box<Expression>>,
11034    #[serde(default)]
11035    pub after: Option<Box<Expression>>,
11036}
11037
11038/// LanguageProperty
11039#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11040#[cfg_attr(feature = "bindings", derive(TS))]
11041pub struct LanguageProperty {
11042    pub this: Box<Expression>,
11043}
11044
11045/// EnviromentProperty
11046#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11047#[cfg_attr(feature = "bindings", derive(TS))]
11048pub struct EnviromentProperty {
11049    #[serde(default)]
11050    pub expressions: Vec<Expression>,
11051}
11052
11053/// ClusteredByProperty
11054#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11055#[cfg_attr(feature = "bindings", derive(TS))]
11056pub struct ClusteredByProperty {
11057    #[serde(default)]
11058    pub expressions: Vec<Expression>,
11059    #[serde(default)]
11060    pub sorted_by: Option<Box<Expression>>,
11061    #[serde(default)]
11062    pub buckets: Option<Box<Expression>>,
11063}
11064
11065/// DictProperty
11066#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11067#[cfg_attr(feature = "bindings", derive(TS))]
11068pub struct DictProperty {
11069    pub this: Box<Expression>,
11070    pub kind: String,
11071    #[serde(default)]
11072    pub settings: Option<Box<Expression>>,
11073}
11074
11075/// DictRange
11076#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11077#[cfg_attr(feature = "bindings", derive(TS))]
11078pub struct DictRange {
11079    pub this: Box<Expression>,
11080    #[serde(default)]
11081    pub min: Option<Box<Expression>>,
11082    #[serde(default)]
11083    pub max: Option<Box<Expression>>,
11084}
11085
11086/// OnCluster
11087#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11088#[cfg_attr(feature = "bindings", derive(TS))]
11089pub struct OnCluster {
11090    pub this: Box<Expression>,
11091}
11092
11093/// LikeProperty
11094#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11095#[cfg_attr(feature = "bindings", derive(TS))]
11096pub struct LikeProperty {
11097    pub this: Box<Expression>,
11098    #[serde(default)]
11099    pub expressions: Vec<Expression>,
11100}
11101
11102/// LocationProperty
11103#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11104#[cfg_attr(feature = "bindings", derive(TS))]
11105pub struct LocationProperty {
11106    pub this: Box<Expression>,
11107}
11108
11109/// LockProperty
11110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11111#[cfg_attr(feature = "bindings", derive(TS))]
11112pub struct LockProperty {
11113    pub this: Box<Expression>,
11114}
11115
11116/// LockingProperty
11117#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11118#[cfg_attr(feature = "bindings", derive(TS))]
11119pub struct LockingProperty {
11120    #[serde(default)]
11121    pub this: Option<Box<Expression>>,
11122    pub kind: String,
11123    #[serde(default)]
11124    pub for_or_in: Option<Box<Expression>>,
11125    #[serde(default)]
11126    pub lock_type: Option<Box<Expression>>,
11127    #[serde(default)]
11128    pub override_: Option<Box<Expression>>,
11129}
11130
11131/// LogProperty
11132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11133#[cfg_attr(feature = "bindings", derive(TS))]
11134pub struct LogProperty {
11135    #[serde(default)]
11136    pub no: Option<Box<Expression>>,
11137}
11138
11139/// MaterializedProperty
11140#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11141#[cfg_attr(feature = "bindings", derive(TS))]
11142pub struct MaterializedProperty {
11143    #[serde(default)]
11144    pub this: Option<Box<Expression>>,
11145}
11146
11147/// MergeBlockRatioProperty
11148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11149#[cfg_attr(feature = "bindings", derive(TS))]
11150pub struct MergeBlockRatioProperty {
11151    #[serde(default)]
11152    pub this: Option<Box<Expression>>,
11153    #[serde(default)]
11154    pub no: Option<Box<Expression>>,
11155    #[serde(default)]
11156    pub default: Option<Box<Expression>>,
11157    #[serde(default)]
11158    pub percent: Option<Box<Expression>>,
11159}
11160
11161/// OnProperty
11162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11163#[cfg_attr(feature = "bindings", derive(TS))]
11164pub struct OnProperty {
11165    pub this: Box<Expression>,
11166}
11167
11168/// OnCommitProperty
11169#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11170#[cfg_attr(feature = "bindings", derive(TS))]
11171pub struct OnCommitProperty {
11172    #[serde(default)]
11173    pub delete: Option<Box<Expression>>,
11174}
11175
11176/// PartitionedByProperty
11177#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11178#[cfg_attr(feature = "bindings", derive(TS))]
11179pub struct PartitionedByProperty {
11180    pub this: Box<Expression>,
11181}
11182
11183/// BigQuery PARTITION BY property in CREATE TABLE statements.
11184#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11185#[cfg_attr(feature = "bindings", derive(TS))]
11186pub struct PartitionByProperty {
11187    #[serde(default)]
11188    pub expressions: Vec<Expression>,
11189}
11190
11191/// PartitionedByBucket
11192#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11193#[cfg_attr(feature = "bindings", derive(TS))]
11194pub struct PartitionedByBucket {
11195    pub this: Box<Expression>,
11196    pub expression: Box<Expression>,
11197}
11198
11199/// BigQuery CLUSTER BY property in CREATE TABLE statements.
11200#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11201#[cfg_attr(feature = "bindings", derive(TS))]
11202pub struct ClusterByColumnsProperty {
11203    #[serde(default)]
11204    pub columns: Vec<Identifier>,
11205}
11206
11207/// PartitionByTruncate
11208#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11209#[cfg_attr(feature = "bindings", derive(TS))]
11210pub struct PartitionByTruncate {
11211    pub this: Box<Expression>,
11212    pub expression: Box<Expression>,
11213}
11214
11215/// PartitionByRangeProperty
11216#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11217#[cfg_attr(feature = "bindings", derive(TS))]
11218pub struct PartitionByRangeProperty {
11219    #[serde(default)]
11220    pub partition_expressions: Option<Box<Expression>>,
11221    #[serde(default)]
11222    pub create_expressions: Option<Box<Expression>>,
11223}
11224
11225/// PartitionByRangePropertyDynamic
11226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11227#[cfg_attr(feature = "bindings", derive(TS))]
11228pub struct PartitionByRangePropertyDynamic {
11229    #[serde(default)]
11230    pub this: Option<Box<Expression>>,
11231    #[serde(default)]
11232    pub start: Option<Box<Expression>>,
11233    /// Use START/END/EVERY keywords (StarRocks) instead of FROM/TO/INTERVAL (Doris)
11234    #[serde(default)]
11235    pub use_start_end: bool,
11236    #[serde(default)]
11237    pub end: Option<Box<Expression>>,
11238    #[serde(default)]
11239    pub every: Option<Box<Expression>>,
11240}
11241
11242/// PartitionByListProperty
11243#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11244#[cfg_attr(feature = "bindings", derive(TS))]
11245pub struct PartitionByListProperty {
11246    #[serde(default)]
11247    pub partition_expressions: Option<Box<Expression>>,
11248    #[serde(default)]
11249    pub create_expressions: Option<Box<Expression>>,
11250}
11251
11252/// PartitionList
11253#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11254#[cfg_attr(feature = "bindings", derive(TS))]
11255pub struct PartitionList {
11256    pub this: Box<Expression>,
11257    #[serde(default)]
11258    pub expressions: Vec<Expression>,
11259}
11260
11261/// Partition - represents PARTITION/SUBPARTITION clause
11262#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11263#[cfg_attr(feature = "bindings", derive(TS))]
11264pub struct Partition {
11265    pub expressions: Vec<Expression>,
11266    #[serde(default)]
11267    pub subpartition: bool,
11268}
11269
11270/// RefreshTriggerProperty - Doris REFRESH clause for materialized views
11271/// e.g., REFRESH COMPLETE ON MANUAL, REFRESH AUTO ON SCHEDULE EVERY 5 MINUTE
11272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11273#[cfg_attr(feature = "bindings", derive(TS))]
11274pub struct RefreshTriggerProperty {
11275    /// Method: COMPLETE or AUTO
11276    pub method: String,
11277    /// Trigger kind: MANUAL, COMMIT, or SCHEDULE
11278    #[serde(default)]
11279    pub kind: Option<String>,
11280    /// For SCHEDULE: EVERY n (the number)
11281    #[serde(default)]
11282    pub every: Option<Box<Expression>>,
11283    /// For SCHEDULE: the time unit (MINUTE, HOUR, DAY, etc.)
11284    #[serde(default)]
11285    pub unit: Option<String>,
11286    /// For SCHEDULE: STARTS 'datetime'
11287    #[serde(default)]
11288    pub starts: Option<Box<Expression>>,
11289}
11290
11291/// UniqueKeyProperty
11292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11293#[cfg_attr(feature = "bindings", derive(TS))]
11294pub struct UniqueKeyProperty {
11295    #[serde(default)]
11296    pub expressions: Vec<Expression>,
11297}
11298
11299/// RollupProperty - StarRocks ROLLUP (index_name(col1, col2), ...)
11300#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11301#[cfg_attr(feature = "bindings", derive(TS))]
11302pub struct RollupProperty {
11303    pub expressions: Vec<RollupIndex>,
11304}
11305
11306/// RollupIndex - A single rollup index: name(col1, col2)
11307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11308#[cfg_attr(feature = "bindings", derive(TS))]
11309pub struct RollupIndex {
11310    pub name: Identifier,
11311    pub expressions: Vec<Identifier>,
11312}
11313
11314/// PartitionBoundSpec
11315#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11316#[cfg_attr(feature = "bindings", derive(TS))]
11317pub struct PartitionBoundSpec {
11318    #[serde(default)]
11319    pub this: Option<Box<Expression>>,
11320    #[serde(default)]
11321    pub expression: Option<Box<Expression>>,
11322    #[serde(default)]
11323    pub from_expressions: Option<Box<Expression>>,
11324    #[serde(default)]
11325    pub to_expressions: Option<Box<Expression>>,
11326}
11327
11328/// PartitionedOfProperty
11329#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11330#[cfg_attr(feature = "bindings", derive(TS))]
11331pub struct PartitionedOfProperty {
11332    pub this: Box<Expression>,
11333    pub expression: Box<Expression>,
11334}
11335
11336/// RemoteWithConnectionModelProperty
11337#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11338#[cfg_attr(feature = "bindings", derive(TS))]
11339pub struct RemoteWithConnectionModelProperty {
11340    pub this: Box<Expression>,
11341}
11342
11343/// ReturnsProperty
11344#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11345#[cfg_attr(feature = "bindings", derive(TS))]
11346pub struct ReturnsProperty {
11347    #[serde(default)]
11348    pub this: Option<Box<Expression>>,
11349    #[serde(default)]
11350    pub is_table: Option<Box<Expression>>,
11351    #[serde(default)]
11352    pub table: Option<Box<Expression>>,
11353    #[serde(default)]
11354    pub null: Option<Box<Expression>>,
11355}
11356
11357/// RowFormatProperty
11358#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11359#[cfg_attr(feature = "bindings", derive(TS))]
11360pub struct RowFormatProperty {
11361    pub this: Box<Expression>,
11362}
11363
11364/// RowFormatDelimitedProperty
11365#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11366#[cfg_attr(feature = "bindings", derive(TS))]
11367pub struct RowFormatDelimitedProperty {
11368    #[serde(default)]
11369    pub fields: Option<Box<Expression>>,
11370    #[serde(default)]
11371    pub escaped: Option<Box<Expression>>,
11372    #[serde(default)]
11373    pub collection_items: Option<Box<Expression>>,
11374    #[serde(default)]
11375    pub map_keys: Option<Box<Expression>>,
11376    #[serde(default)]
11377    pub lines: Option<Box<Expression>>,
11378    #[serde(default)]
11379    pub null: Option<Box<Expression>>,
11380    #[serde(default)]
11381    pub serde: Option<Box<Expression>>,
11382}
11383
11384/// RowFormatSerdeProperty
11385#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11386#[cfg_attr(feature = "bindings", derive(TS))]
11387pub struct RowFormatSerdeProperty {
11388    pub this: Box<Expression>,
11389    #[serde(default)]
11390    pub serde_properties: Option<Box<Expression>>,
11391}
11392
11393/// QueryTransform
11394#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11395#[cfg_attr(feature = "bindings", derive(TS))]
11396pub struct QueryTransform {
11397    #[serde(default)]
11398    pub expressions: Vec<Expression>,
11399    #[serde(default)]
11400    pub command_script: Option<Box<Expression>>,
11401    #[serde(default)]
11402    pub schema: Option<Box<Expression>>,
11403    #[serde(default)]
11404    pub row_format_before: Option<Box<Expression>>,
11405    #[serde(default)]
11406    pub record_writer: Option<Box<Expression>>,
11407    #[serde(default)]
11408    pub row_format_after: Option<Box<Expression>>,
11409    #[serde(default)]
11410    pub record_reader: Option<Box<Expression>>,
11411}
11412
11413/// SampleProperty
11414#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11415#[cfg_attr(feature = "bindings", derive(TS))]
11416pub struct SampleProperty {
11417    pub this: Box<Expression>,
11418}
11419
11420/// SecurityProperty
11421#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11422#[cfg_attr(feature = "bindings", derive(TS))]
11423pub struct SecurityProperty {
11424    pub this: Box<Expression>,
11425}
11426
11427/// SchemaCommentProperty
11428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11429#[cfg_attr(feature = "bindings", derive(TS))]
11430pub struct SchemaCommentProperty {
11431    pub this: Box<Expression>,
11432}
11433
11434/// SemanticView
11435#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11436#[cfg_attr(feature = "bindings", derive(TS))]
11437pub struct SemanticView {
11438    pub this: Box<Expression>,
11439    #[serde(default)]
11440    pub metrics: Option<Box<Expression>>,
11441    #[serde(default)]
11442    pub dimensions: Option<Box<Expression>>,
11443    #[serde(default)]
11444    pub facts: Option<Box<Expression>>,
11445    #[serde(default)]
11446    pub where_: Option<Box<Expression>>,
11447}
11448
11449/// SerdeProperties
11450#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11451#[cfg_attr(feature = "bindings", derive(TS))]
11452pub struct SerdeProperties {
11453    #[serde(default)]
11454    pub expressions: Vec<Expression>,
11455    #[serde(default)]
11456    pub with_: Option<Box<Expression>>,
11457}
11458
11459/// SetProperty
11460#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11461#[cfg_attr(feature = "bindings", derive(TS))]
11462pub struct SetProperty {
11463    #[serde(default)]
11464    pub multi: Option<Box<Expression>>,
11465}
11466
11467/// SharingProperty
11468#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11469#[cfg_attr(feature = "bindings", derive(TS))]
11470pub struct SharingProperty {
11471    #[serde(default)]
11472    pub this: Option<Box<Expression>>,
11473}
11474
11475/// SetConfigProperty
11476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11477#[cfg_attr(feature = "bindings", derive(TS))]
11478pub struct SetConfigProperty {
11479    pub this: Box<Expression>,
11480}
11481
11482/// SettingsProperty
11483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11484#[cfg_attr(feature = "bindings", derive(TS))]
11485pub struct SettingsProperty {
11486    #[serde(default)]
11487    pub expressions: Vec<Expression>,
11488}
11489
11490/// SortKeyProperty
11491#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11492#[cfg_attr(feature = "bindings", derive(TS))]
11493pub struct SortKeyProperty {
11494    pub this: Box<Expression>,
11495    #[serde(default)]
11496    pub compound: Option<Box<Expression>>,
11497}
11498
11499/// SqlReadWriteProperty
11500#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11501#[cfg_attr(feature = "bindings", derive(TS))]
11502pub struct SqlReadWriteProperty {
11503    pub this: Box<Expression>,
11504}
11505
11506/// SqlSecurityProperty
11507#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11508#[cfg_attr(feature = "bindings", derive(TS))]
11509pub struct SqlSecurityProperty {
11510    pub this: Box<Expression>,
11511}
11512
11513/// StabilityProperty
11514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11515#[cfg_attr(feature = "bindings", derive(TS))]
11516pub struct StabilityProperty {
11517    pub this: Box<Expression>,
11518}
11519
11520/// StorageHandlerProperty
11521#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11522#[cfg_attr(feature = "bindings", derive(TS))]
11523pub struct StorageHandlerProperty {
11524    pub this: Box<Expression>,
11525}
11526
11527/// TemporaryProperty
11528#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11529#[cfg_attr(feature = "bindings", derive(TS))]
11530pub struct TemporaryProperty {
11531    #[serde(default)]
11532    pub this: Option<Box<Expression>>,
11533}
11534
11535/// Tags
11536#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11537#[cfg_attr(feature = "bindings", derive(TS))]
11538pub struct Tags {
11539    #[serde(default)]
11540    pub expressions: Vec<Expression>,
11541}
11542
11543/// TransformModelProperty
11544#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11545#[cfg_attr(feature = "bindings", derive(TS))]
11546pub struct TransformModelProperty {
11547    #[serde(default)]
11548    pub expressions: Vec<Expression>,
11549}
11550
11551/// TransientProperty
11552#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11553#[cfg_attr(feature = "bindings", derive(TS))]
11554pub struct TransientProperty {
11555    #[serde(default)]
11556    pub this: Option<Box<Expression>>,
11557}
11558
11559/// UsingTemplateProperty
11560#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11561#[cfg_attr(feature = "bindings", derive(TS))]
11562pub struct UsingTemplateProperty {
11563    pub this: Box<Expression>,
11564}
11565
11566/// ViewAttributeProperty
11567#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11568#[cfg_attr(feature = "bindings", derive(TS))]
11569pub struct ViewAttributeProperty {
11570    pub this: Box<Expression>,
11571}
11572
11573/// VolatileProperty
11574#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11575#[cfg_attr(feature = "bindings", derive(TS))]
11576pub struct VolatileProperty {
11577    #[serde(default)]
11578    pub this: Option<Box<Expression>>,
11579}
11580
11581/// WithDataProperty
11582#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11583#[cfg_attr(feature = "bindings", derive(TS))]
11584pub struct WithDataProperty {
11585    #[serde(default)]
11586    pub no: Option<Box<Expression>>,
11587    #[serde(default)]
11588    pub statistics: Option<Box<Expression>>,
11589}
11590
11591/// WithJournalTableProperty
11592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11593#[cfg_attr(feature = "bindings", derive(TS))]
11594pub struct WithJournalTableProperty {
11595    pub this: Box<Expression>,
11596}
11597
11598/// WithSchemaBindingProperty
11599#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11600#[cfg_attr(feature = "bindings", derive(TS))]
11601pub struct WithSchemaBindingProperty {
11602    pub this: Box<Expression>,
11603}
11604
11605/// WithSystemVersioningProperty
11606#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11607#[cfg_attr(feature = "bindings", derive(TS))]
11608pub struct WithSystemVersioningProperty {
11609    #[serde(default)]
11610    pub on: Option<Box<Expression>>,
11611    #[serde(default)]
11612    pub this: Option<Box<Expression>>,
11613    #[serde(default)]
11614    pub data_consistency: Option<Box<Expression>>,
11615    #[serde(default)]
11616    pub retention_period: Option<Box<Expression>>,
11617    #[serde(default)]
11618    pub with_: Option<Box<Expression>>,
11619}
11620
11621/// WithProcedureOptions
11622#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11623#[cfg_attr(feature = "bindings", derive(TS))]
11624pub struct WithProcedureOptions {
11625    #[serde(default)]
11626    pub expressions: Vec<Expression>,
11627}
11628
11629/// EncodeProperty
11630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11631#[cfg_attr(feature = "bindings", derive(TS))]
11632pub struct EncodeProperty {
11633    pub this: Box<Expression>,
11634    #[serde(default)]
11635    pub properties: Vec<Expression>,
11636    #[serde(default)]
11637    pub key: Option<Box<Expression>>,
11638}
11639
11640/// IncludeProperty
11641#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11642#[cfg_attr(feature = "bindings", derive(TS))]
11643pub struct IncludeProperty {
11644    pub this: Box<Expression>,
11645    #[serde(default)]
11646    pub alias: Option<String>,
11647    #[serde(default)]
11648    pub column_def: Option<Box<Expression>>,
11649}
11650
11651/// Properties
11652#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11653#[cfg_attr(feature = "bindings", derive(TS))]
11654pub struct Properties {
11655    #[serde(default)]
11656    pub expressions: Vec<Expression>,
11657}
11658
11659/// Key/value pair in a BigQuery OPTIONS (...) clause.
11660#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11661#[cfg_attr(feature = "bindings", derive(TS))]
11662pub struct OptionEntry {
11663    pub key: Identifier,
11664    pub value: Expression,
11665}
11666
11667/// Typed BigQuery OPTIONS (...) property for CREATE TABLE and related DDL.
11668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11669#[cfg_attr(feature = "bindings", derive(TS))]
11670pub struct OptionsProperty {
11671    #[serde(default)]
11672    pub entries: Vec<OptionEntry>,
11673}
11674
11675/// InputOutputFormat
11676#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11677#[cfg_attr(feature = "bindings", derive(TS))]
11678pub struct InputOutputFormat {
11679    #[serde(default)]
11680    pub input_format: Option<Box<Expression>>,
11681    #[serde(default)]
11682    pub output_format: Option<Box<Expression>>,
11683}
11684
11685/// Reference
11686#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11687#[cfg_attr(feature = "bindings", derive(TS))]
11688pub struct Reference {
11689    pub this: Box<Expression>,
11690    #[serde(default)]
11691    pub expressions: Vec<Expression>,
11692    #[serde(default)]
11693    pub options: Vec<Expression>,
11694}
11695
11696/// QueryOption
11697#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11698#[cfg_attr(feature = "bindings", derive(TS))]
11699pub struct QueryOption {
11700    pub this: Box<Expression>,
11701    #[serde(default)]
11702    pub expression: Option<Box<Expression>>,
11703}
11704
11705/// WithTableHint
11706#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11707#[cfg_attr(feature = "bindings", derive(TS))]
11708pub struct WithTableHint {
11709    #[serde(default)]
11710    pub expressions: Vec<Expression>,
11711}
11712
11713/// IndexTableHint
11714#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11715#[cfg_attr(feature = "bindings", derive(TS))]
11716pub struct IndexTableHint {
11717    pub this: Box<Expression>,
11718    #[serde(default)]
11719    pub expressions: Vec<Expression>,
11720    #[serde(default)]
11721    pub target: Option<Box<Expression>>,
11722}
11723
11724/// Get
11725#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11726#[cfg_attr(feature = "bindings", derive(TS))]
11727pub struct Get {
11728    pub this: Box<Expression>,
11729    #[serde(default)]
11730    pub target: Option<Box<Expression>>,
11731    #[serde(default)]
11732    pub properties: Vec<Expression>,
11733}
11734
11735/// SetOperation
11736#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11737#[cfg_attr(feature = "bindings", derive(TS))]
11738pub struct SetOperation {
11739    #[serde(default)]
11740    pub with_: Option<Box<Expression>>,
11741    pub this: Box<Expression>,
11742    pub expression: Box<Expression>,
11743    #[serde(default)]
11744    pub distinct: bool,
11745    #[serde(default)]
11746    pub by_name: Option<Box<Expression>>,
11747    #[serde(default)]
11748    pub side: Option<Box<Expression>>,
11749    #[serde(default)]
11750    pub kind: Option<String>,
11751    #[serde(default)]
11752    pub on: Option<Box<Expression>>,
11753}
11754
11755/// Var - Simple variable reference (for SQL variables, keywords as values)
11756#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11757#[cfg_attr(feature = "bindings", derive(TS))]
11758pub struct Var {
11759    pub this: String,
11760}
11761
11762/// Variadic - represents VARIADIC prefix on function arguments (PostgreSQL)
11763#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11764#[cfg_attr(feature = "bindings", derive(TS))]
11765pub struct Variadic {
11766    pub this: Box<Expression>,
11767}
11768
11769/// Version
11770#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11771#[cfg_attr(feature = "bindings", derive(TS))]
11772pub struct Version {
11773    pub this: Box<Expression>,
11774    pub kind: String,
11775    #[serde(default)]
11776    pub expression: Option<Box<Expression>>,
11777}
11778
11779/// Schema
11780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11781#[cfg_attr(feature = "bindings", derive(TS))]
11782pub struct Schema {
11783    #[serde(default)]
11784    pub this: Option<Box<Expression>>,
11785    #[serde(default)]
11786    pub expressions: Vec<Expression>,
11787}
11788
11789/// Lock
11790#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11791#[cfg_attr(feature = "bindings", derive(TS))]
11792pub struct Lock {
11793    #[serde(default)]
11794    pub update: Option<Box<Expression>>,
11795    #[serde(default)]
11796    pub expressions: Vec<Expression>,
11797    #[serde(default)]
11798    pub wait: Option<Box<Expression>>,
11799    #[serde(default)]
11800    pub key: Option<Box<Expression>>,
11801}
11802
11803/// TableSample - wraps an expression with a TABLESAMPLE clause
11804/// Used when TABLESAMPLE follows a non-Table expression (subquery, function, etc.)
11805#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11806#[cfg_attr(feature = "bindings", derive(TS))]
11807pub struct TableSample {
11808    /// The expression being sampled (subquery, function, etc.)
11809    #[serde(default, skip_serializing_if = "Option::is_none")]
11810    pub this: Option<Box<Expression>>,
11811    /// The sample specification
11812    #[serde(default, skip_serializing_if = "Option::is_none")]
11813    pub sample: Option<Box<Sample>>,
11814    #[serde(default)]
11815    pub expressions: Vec<Expression>,
11816    #[serde(default)]
11817    pub method: Option<String>,
11818    #[serde(default)]
11819    pub bucket_numerator: Option<Box<Expression>>,
11820    #[serde(default)]
11821    pub bucket_denominator: Option<Box<Expression>>,
11822    #[serde(default)]
11823    pub bucket_field: Option<Box<Expression>>,
11824    #[serde(default)]
11825    pub percent: Option<Box<Expression>>,
11826    #[serde(default)]
11827    pub rows: Option<Box<Expression>>,
11828    #[serde(default)]
11829    pub size: Option<i64>,
11830    #[serde(default)]
11831    pub seed: Option<Box<Expression>>,
11832}
11833
11834/// Tags are used for generating arbitrary sql like SELECT <span>x</span>.
11835#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11836#[cfg_attr(feature = "bindings", derive(TS))]
11837pub struct Tag {
11838    #[serde(default)]
11839    pub this: Option<Box<Expression>>,
11840    #[serde(default)]
11841    pub prefix: Option<Box<Expression>>,
11842    #[serde(default)]
11843    pub postfix: Option<Box<Expression>>,
11844}
11845
11846/// UnpivotColumns
11847#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11848#[cfg_attr(feature = "bindings", derive(TS))]
11849pub struct UnpivotColumns {
11850    pub this: Box<Expression>,
11851    #[serde(default)]
11852    pub expressions: Vec<Expression>,
11853}
11854
11855/// SessionParameter
11856#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11857#[cfg_attr(feature = "bindings", derive(TS))]
11858pub struct SessionParameter {
11859    pub this: Box<Expression>,
11860    #[serde(default)]
11861    pub kind: Option<String>,
11862}
11863
11864/// PseudoType
11865#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11866#[cfg_attr(feature = "bindings", derive(TS))]
11867pub struct PseudoType {
11868    pub this: Box<Expression>,
11869}
11870
11871/// ObjectIdentifier
11872#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11873#[cfg_attr(feature = "bindings", derive(TS))]
11874pub struct ObjectIdentifier {
11875    pub this: Box<Expression>,
11876}
11877
11878/// Transaction
11879#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11880#[cfg_attr(feature = "bindings", derive(TS))]
11881pub struct Transaction {
11882    #[serde(default)]
11883    pub this: Option<Box<Expression>>,
11884    #[serde(default)]
11885    pub modes: Option<Box<Expression>>,
11886    #[serde(default)]
11887    pub mark: Option<Box<Expression>>,
11888}
11889
11890/// Commit
11891#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11892#[cfg_attr(feature = "bindings", derive(TS))]
11893pub struct Commit {
11894    #[serde(default)]
11895    pub chain: Option<Box<Expression>>,
11896    #[serde(default)]
11897    pub this: Option<Box<Expression>>,
11898    #[serde(default)]
11899    pub durability: Option<Box<Expression>>,
11900}
11901
11902/// Rollback
11903#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11904#[cfg_attr(feature = "bindings", derive(TS))]
11905pub struct Rollback {
11906    #[serde(default)]
11907    pub savepoint: Option<Box<Expression>>,
11908    #[serde(default)]
11909    pub this: Option<Box<Expression>>,
11910}
11911
11912/// AlterSession
11913#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11914#[cfg_attr(feature = "bindings", derive(TS))]
11915pub struct AlterSession {
11916    #[serde(default)]
11917    pub expressions: Vec<Expression>,
11918    #[serde(default)]
11919    pub unset: Option<Box<Expression>>,
11920}
11921
11922/// Analyze
11923#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11924#[cfg_attr(feature = "bindings", derive(TS))]
11925pub struct Analyze {
11926    #[serde(default)]
11927    pub kind: Option<String>,
11928    #[serde(default)]
11929    pub this: Option<Box<Expression>>,
11930    #[serde(default)]
11931    pub options: Vec<Expression>,
11932    #[serde(default)]
11933    pub mode: Option<Box<Expression>>,
11934    #[serde(default)]
11935    pub partition: Option<Box<Expression>>,
11936    #[serde(default)]
11937    pub expression: Option<Box<Expression>>,
11938    #[serde(default)]
11939    pub properties: Vec<Expression>,
11940    /// Column list for ANALYZE tbl(col1, col2) syntax (PostgreSQL)
11941    #[serde(default, skip_serializing_if = "Vec::is_empty")]
11942    pub columns: Vec<String>,
11943}
11944
11945/// AnalyzeStatistics
11946#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11947#[cfg_attr(feature = "bindings", derive(TS))]
11948pub struct AnalyzeStatistics {
11949    pub kind: String,
11950    #[serde(default)]
11951    pub option: Option<Box<Expression>>,
11952    #[serde(default)]
11953    pub this: Option<Box<Expression>>,
11954    #[serde(default)]
11955    pub expressions: Vec<Expression>,
11956}
11957
11958/// AnalyzeHistogram
11959#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11960#[cfg_attr(feature = "bindings", derive(TS))]
11961pub struct AnalyzeHistogram {
11962    pub this: Box<Expression>,
11963    #[serde(default)]
11964    pub expressions: Vec<Expression>,
11965    #[serde(default)]
11966    pub expression: Option<Box<Expression>>,
11967    #[serde(default)]
11968    pub update_options: Option<Box<Expression>>,
11969}
11970
11971/// AnalyzeSample
11972#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11973#[cfg_attr(feature = "bindings", derive(TS))]
11974pub struct AnalyzeSample {
11975    pub kind: String,
11976    #[serde(default)]
11977    pub sample: Option<Box<Expression>>,
11978}
11979
11980/// AnalyzeListChainedRows
11981#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11982#[cfg_attr(feature = "bindings", derive(TS))]
11983pub struct AnalyzeListChainedRows {
11984    #[serde(default)]
11985    pub expression: Option<Box<Expression>>,
11986}
11987
11988/// AnalyzeDelete
11989#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11990#[cfg_attr(feature = "bindings", derive(TS))]
11991pub struct AnalyzeDelete {
11992    #[serde(default)]
11993    pub kind: Option<String>,
11994}
11995
11996/// AnalyzeWith
11997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11998#[cfg_attr(feature = "bindings", derive(TS))]
11999pub struct AnalyzeWith {
12000    #[serde(default)]
12001    pub expressions: Vec<Expression>,
12002}
12003
12004/// AnalyzeValidate
12005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12006#[cfg_attr(feature = "bindings", derive(TS))]
12007pub struct AnalyzeValidate {
12008    pub kind: String,
12009    #[serde(default)]
12010    pub this: Option<Box<Expression>>,
12011    #[serde(default)]
12012    pub expression: Option<Box<Expression>>,
12013}
12014
12015/// AddPartition
12016#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12017#[cfg_attr(feature = "bindings", derive(TS))]
12018pub struct AddPartition {
12019    pub this: Box<Expression>,
12020    #[serde(default)]
12021    pub exists: bool,
12022    #[serde(default)]
12023    pub location: Option<Box<Expression>>,
12024}
12025
12026/// AttachOption
12027#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12028#[cfg_attr(feature = "bindings", derive(TS))]
12029pub struct AttachOption {
12030    pub this: Box<Expression>,
12031    #[serde(default)]
12032    pub expression: Option<Box<Expression>>,
12033}
12034
12035/// DropPartition
12036#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12037#[cfg_attr(feature = "bindings", derive(TS))]
12038pub struct DropPartition {
12039    #[serde(default)]
12040    pub expressions: Vec<Expression>,
12041    #[serde(default)]
12042    pub exists: bool,
12043}
12044
12045/// ReplacePartition
12046#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12047#[cfg_attr(feature = "bindings", derive(TS))]
12048pub struct ReplacePartition {
12049    pub expression: Box<Expression>,
12050    #[serde(default)]
12051    pub source: Option<Box<Expression>>,
12052}
12053
12054/// DPipe
12055#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12056#[cfg_attr(feature = "bindings", derive(TS))]
12057pub struct DPipe {
12058    pub this: Box<Expression>,
12059    pub expression: Box<Expression>,
12060    #[serde(default)]
12061    pub safe: Option<Box<Expression>>,
12062}
12063
12064/// Operator
12065#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12066#[cfg_attr(feature = "bindings", derive(TS))]
12067pub struct Operator {
12068    pub this: Box<Expression>,
12069    #[serde(default)]
12070    pub operator: Option<Box<Expression>>,
12071    pub expression: Box<Expression>,
12072    /// Comments between OPERATOR() and the RHS expression
12073    #[serde(default, skip_serializing_if = "Vec::is_empty")]
12074    pub comments: Vec<String>,
12075}
12076
12077/// PivotAny
12078#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12079#[cfg_attr(feature = "bindings", derive(TS))]
12080pub struct PivotAny {
12081    #[serde(default)]
12082    pub this: Option<Box<Expression>>,
12083}
12084
12085/// Aliases
12086#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12087#[cfg_attr(feature = "bindings", derive(TS))]
12088pub struct Aliases {
12089    pub this: Box<Expression>,
12090    #[serde(default)]
12091    pub expressions: Vec<Expression>,
12092}
12093
12094/// AtIndex
12095#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12096#[cfg_attr(feature = "bindings", derive(TS))]
12097pub struct AtIndex {
12098    pub this: Box<Expression>,
12099    pub expression: Box<Expression>,
12100}
12101
12102/// FromTimeZone
12103#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12104#[cfg_attr(feature = "bindings", derive(TS))]
12105pub struct FromTimeZone {
12106    pub this: Box<Expression>,
12107    #[serde(default)]
12108    pub zone: Option<Box<Expression>>,
12109}
12110
12111/// Format override for a column in Teradata
12112#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12113#[cfg_attr(feature = "bindings", derive(TS))]
12114pub struct FormatPhrase {
12115    pub this: Box<Expression>,
12116    pub format: String,
12117}
12118
12119/// ForIn
12120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12121#[cfg_attr(feature = "bindings", derive(TS))]
12122pub struct ForIn {
12123    pub this: Box<Expression>,
12124    pub expression: Box<Expression>,
12125}
12126
12127/// Automatically converts unit arg into a var.
12128#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12129#[cfg_attr(feature = "bindings", derive(TS))]
12130pub struct TimeUnit {
12131    #[serde(default)]
12132    pub unit: Option<String>,
12133}
12134
12135/// IntervalOp
12136#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12137#[cfg_attr(feature = "bindings", derive(TS))]
12138pub struct IntervalOp {
12139    #[serde(default)]
12140    pub unit: Option<String>,
12141    pub expression: Box<Expression>,
12142}
12143
12144/// HavingMax
12145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12146#[cfg_attr(feature = "bindings", derive(TS))]
12147pub struct HavingMax {
12148    pub this: Box<Expression>,
12149    pub expression: Box<Expression>,
12150    #[serde(default)]
12151    pub max: Option<Box<Expression>>,
12152}
12153
12154/// CosineDistance
12155#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12156#[cfg_attr(feature = "bindings", derive(TS))]
12157pub struct CosineDistance {
12158    pub this: Box<Expression>,
12159    pub expression: Box<Expression>,
12160}
12161
12162/// DotProduct
12163#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12164#[cfg_attr(feature = "bindings", derive(TS))]
12165pub struct DotProduct {
12166    pub this: Box<Expression>,
12167    pub expression: Box<Expression>,
12168}
12169
12170/// EuclideanDistance
12171#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12172#[cfg_attr(feature = "bindings", derive(TS))]
12173pub struct EuclideanDistance {
12174    pub this: Box<Expression>,
12175    pub expression: Box<Expression>,
12176}
12177
12178/// ManhattanDistance
12179#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12180#[cfg_attr(feature = "bindings", derive(TS))]
12181pub struct ManhattanDistance {
12182    pub this: Box<Expression>,
12183    pub expression: Box<Expression>,
12184}
12185
12186/// JarowinklerSimilarity
12187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12188#[cfg_attr(feature = "bindings", derive(TS))]
12189pub struct JarowinklerSimilarity {
12190    pub this: Box<Expression>,
12191    pub expression: Box<Expression>,
12192}
12193
12194/// Booland
12195#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12196#[cfg_attr(feature = "bindings", derive(TS))]
12197pub struct Booland {
12198    pub this: Box<Expression>,
12199    pub expression: Box<Expression>,
12200}
12201
12202/// Boolor
12203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12204#[cfg_attr(feature = "bindings", derive(TS))]
12205pub struct Boolor {
12206    pub this: Box<Expression>,
12207    pub expression: Box<Expression>,
12208}
12209
12210/// ParameterizedAgg
12211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12212#[cfg_attr(feature = "bindings", derive(TS))]
12213pub struct ParameterizedAgg {
12214    pub this: Box<Expression>,
12215    #[serde(default)]
12216    pub expressions: Vec<Expression>,
12217    #[serde(default)]
12218    pub params: Vec<Expression>,
12219}
12220
12221/// ArgMax
12222#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12223#[cfg_attr(feature = "bindings", derive(TS))]
12224pub struct ArgMax {
12225    pub this: Box<Expression>,
12226    pub expression: Box<Expression>,
12227    #[serde(default)]
12228    pub count: Option<Box<Expression>>,
12229}
12230
12231/// ArgMin
12232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12233#[cfg_attr(feature = "bindings", derive(TS))]
12234pub struct ArgMin {
12235    pub this: Box<Expression>,
12236    pub expression: Box<Expression>,
12237    #[serde(default)]
12238    pub count: Option<Box<Expression>>,
12239}
12240
12241/// ApproxTopK
12242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12243#[cfg_attr(feature = "bindings", derive(TS))]
12244pub struct ApproxTopK {
12245    pub this: Box<Expression>,
12246    #[serde(default)]
12247    pub expression: Option<Box<Expression>>,
12248    #[serde(default)]
12249    pub counters: Option<Box<Expression>>,
12250}
12251
12252/// ApproxTopKAccumulate
12253#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12254#[cfg_attr(feature = "bindings", derive(TS))]
12255pub struct ApproxTopKAccumulate {
12256    pub this: Box<Expression>,
12257    #[serde(default)]
12258    pub expression: Option<Box<Expression>>,
12259}
12260
12261/// ApproxTopKCombine
12262#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12263#[cfg_attr(feature = "bindings", derive(TS))]
12264pub struct ApproxTopKCombine {
12265    pub this: Box<Expression>,
12266    #[serde(default)]
12267    pub expression: Option<Box<Expression>>,
12268}
12269
12270/// ApproxTopKEstimate
12271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12272#[cfg_attr(feature = "bindings", derive(TS))]
12273pub struct ApproxTopKEstimate {
12274    pub this: Box<Expression>,
12275    #[serde(default)]
12276    pub expression: Option<Box<Expression>>,
12277}
12278
12279/// ApproxTopSum
12280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12281#[cfg_attr(feature = "bindings", derive(TS))]
12282pub struct ApproxTopSum {
12283    pub this: Box<Expression>,
12284    pub expression: Box<Expression>,
12285    #[serde(default)]
12286    pub count: Option<Box<Expression>>,
12287}
12288
12289/// ApproxQuantiles
12290#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12291#[cfg_attr(feature = "bindings", derive(TS))]
12292pub struct ApproxQuantiles {
12293    pub this: Box<Expression>,
12294    #[serde(default)]
12295    pub expression: Option<Box<Expression>>,
12296}
12297
12298/// Minhash
12299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12300#[cfg_attr(feature = "bindings", derive(TS))]
12301pub struct Minhash {
12302    pub this: Box<Expression>,
12303    #[serde(default)]
12304    pub expressions: Vec<Expression>,
12305}
12306
12307/// FarmFingerprint
12308#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12309#[cfg_attr(feature = "bindings", derive(TS))]
12310pub struct FarmFingerprint {
12311    #[serde(default)]
12312    pub expressions: Vec<Expression>,
12313}
12314
12315/// Float64
12316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12317#[cfg_attr(feature = "bindings", derive(TS))]
12318pub struct Float64 {
12319    pub this: Box<Expression>,
12320    #[serde(default)]
12321    pub expression: Option<Box<Expression>>,
12322}
12323
12324/// Transform
12325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12326#[cfg_attr(feature = "bindings", derive(TS))]
12327pub struct Transform {
12328    pub this: Box<Expression>,
12329    pub expression: Box<Expression>,
12330}
12331
12332/// Translate
12333#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12334#[cfg_attr(feature = "bindings", derive(TS))]
12335pub struct Translate {
12336    pub this: Box<Expression>,
12337    #[serde(default)]
12338    pub from_: Option<Box<Expression>>,
12339    #[serde(default)]
12340    pub to: Option<Box<Expression>>,
12341}
12342
12343/// Grouping
12344#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12345#[cfg_attr(feature = "bindings", derive(TS))]
12346pub struct Grouping {
12347    #[serde(default)]
12348    pub expressions: Vec<Expression>,
12349}
12350
12351/// GroupingId
12352#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12353#[cfg_attr(feature = "bindings", derive(TS))]
12354pub struct GroupingId {
12355    #[serde(default)]
12356    pub expressions: Vec<Expression>,
12357}
12358
12359/// Anonymous
12360#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12361#[cfg_attr(feature = "bindings", derive(TS))]
12362pub struct Anonymous {
12363    pub this: Box<Expression>,
12364    #[serde(default)]
12365    pub expressions: Vec<Expression>,
12366}
12367
12368/// AnonymousAggFunc
12369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12370#[cfg_attr(feature = "bindings", derive(TS))]
12371pub struct AnonymousAggFunc {
12372    pub this: Box<Expression>,
12373    #[serde(default)]
12374    pub expressions: Vec<Expression>,
12375}
12376
12377/// CombinedAggFunc
12378#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12379#[cfg_attr(feature = "bindings", derive(TS))]
12380pub struct CombinedAggFunc {
12381    pub this: Box<Expression>,
12382    #[serde(default)]
12383    pub expressions: Vec<Expression>,
12384}
12385
12386/// CombinedParameterizedAgg
12387#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12388#[cfg_attr(feature = "bindings", derive(TS))]
12389pub struct CombinedParameterizedAgg {
12390    pub this: Box<Expression>,
12391    #[serde(default)]
12392    pub expressions: Vec<Expression>,
12393    #[serde(default)]
12394    pub params: Vec<Expression>,
12395}
12396
12397/// HashAgg
12398#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12399#[cfg_attr(feature = "bindings", derive(TS))]
12400pub struct HashAgg {
12401    pub this: Box<Expression>,
12402    #[serde(default)]
12403    pub expressions: Vec<Expression>,
12404}
12405
12406/// Hll
12407#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12408#[cfg_attr(feature = "bindings", derive(TS))]
12409pub struct Hll {
12410    pub this: Box<Expression>,
12411    #[serde(default)]
12412    pub expressions: Vec<Expression>,
12413}
12414
12415/// Apply
12416#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12417#[cfg_attr(feature = "bindings", derive(TS))]
12418pub struct Apply {
12419    pub this: Box<Expression>,
12420    pub expression: Box<Expression>,
12421}
12422
12423/// ToBoolean
12424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12425#[cfg_attr(feature = "bindings", derive(TS))]
12426pub struct ToBoolean {
12427    pub this: Box<Expression>,
12428    #[serde(default)]
12429    pub safe: Option<Box<Expression>>,
12430}
12431
12432/// List
12433#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12434#[cfg_attr(feature = "bindings", derive(TS))]
12435pub struct List {
12436    #[serde(default)]
12437    pub expressions: Vec<Expression>,
12438}
12439
12440/// ToMap - Materialize-style map constructor
12441/// Can hold either:
12442/// - A SELECT subquery (MAP(SELECT 'a', 1))
12443/// - A struct with key=>value entries (MAP['a' => 1, 'b' => 2])
12444#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12445#[cfg_attr(feature = "bindings", derive(TS))]
12446pub struct ToMap {
12447    /// Either a Select subquery or a Struct containing PropertyEQ entries
12448    pub this: Box<Expression>,
12449}
12450
12451/// Pad
12452#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12453#[cfg_attr(feature = "bindings", derive(TS))]
12454pub struct Pad {
12455    pub this: Box<Expression>,
12456    pub expression: Box<Expression>,
12457    #[serde(default)]
12458    pub fill_pattern: Option<Box<Expression>>,
12459    #[serde(default)]
12460    pub is_left: Option<Box<Expression>>,
12461}
12462
12463/// ToChar
12464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12465#[cfg_attr(feature = "bindings", derive(TS))]
12466pub struct ToChar {
12467    pub this: Box<Expression>,
12468    #[serde(default)]
12469    pub format: Option<String>,
12470    #[serde(default)]
12471    pub nlsparam: Option<Box<Expression>>,
12472    #[serde(default)]
12473    pub is_numeric: Option<Box<Expression>>,
12474}
12475
12476/// StringFunc - String type conversion function (BigQuery STRING)
12477#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12478#[cfg_attr(feature = "bindings", derive(TS))]
12479pub struct StringFunc {
12480    pub this: Box<Expression>,
12481    #[serde(default)]
12482    pub zone: Option<Box<Expression>>,
12483}
12484
12485/// ToNumber
12486#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12487#[cfg_attr(feature = "bindings", derive(TS))]
12488pub struct ToNumber {
12489    pub this: Box<Expression>,
12490    #[serde(default)]
12491    pub format: Option<Box<Expression>>,
12492    #[serde(default)]
12493    pub nlsparam: Option<Box<Expression>>,
12494    #[serde(default)]
12495    pub precision: Option<Box<Expression>>,
12496    #[serde(default)]
12497    pub scale: Option<Box<Expression>>,
12498    #[serde(default)]
12499    pub safe: Option<Box<Expression>>,
12500    #[serde(default)]
12501    pub safe_name: Option<Box<Expression>>,
12502}
12503
12504/// ToDouble
12505#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12506#[cfg_attr(feature = "bindings", derive(TS))]
12507pub struct ToDouble {
12508    pub this: Box<Expression>,
12509    #[serde(default)]
12510    pub format: Option<String>,
12511    #[serde(default)]
12512    pub safe: Option<Box<Expression>>,
12513}
12514
12515/// ToDecfloat
12516#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12517#[cfg_attr(feature = "bindings", derive(TS))]
12518pub struct ToDecfloat {
12519    pub this: Box<Expression>,
12520    #[serde(default)]
12521    pub format: Option<String>,
12522}
12523
12524/// TryToDecfloat
12525#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12526#[cfg_attr(feature = "bindings", derive(TS))]
12527pub struct TryToDecfloat {
12528    pub this: Box<Expression>,
12529    #[serde(default)]
12530    pub format: Option<String>,
12531}
12532
12533/// ToFile
12534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12535#[cfg_attr(feature = "bindings", derive(TS))]
12536pub struct ToFile {
12537    pub this: Box<Expression>,
12538    #[serde(default)]
12539    pub path: Option<Box<Expression>>,
12540    #[serde(default)]
12541    pub safe: Option<Box<Expression>>,
12542}
12543
12544/// Columns
12545#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12546#[cfg_attr(feature = "bindings", derive(TS))]
12547pub struct Columns {
12548    pub this: Box<Expression>,
12549    #[serde(default)]
12550    pub unpack: Option<Box<Expression>>,
12551}
12552
12553/// ConvertToCharset
12554#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12555#[cfg_attr(feature = "bindings", derive(TS))]
12556pub struct ConvertToCharset {
12557    pub this: Box<Expression>,
12558    #[serde(default)]
12559    pub dest: Option<Box<Expression>>,
12560    #[serde(default)]
12561    pub source: Option<Box<Expression>>,
12562}
12563
12564/// ConvertTimezone
12565#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12566#[cfg_attr(feature = "bindings", derive(TS))]
12567pub struct ConvertTimezone {
12568    #[serde(default)]
12569    pub source_tz: Option<Box<Expression>>,
12570    #[serde(default)]
12571    pub target_tz: Option<Box<Expression>>,
12572    #[serde(default)]
12573    pub timestamp: Option<Box<Expression>>,
12574    #[serde(default)]
12575    pub options: Vec<Expression>,
12576}
12577
12578/// GenerateSeries
12579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12580#[cfg_attr(feature = "bindings", derive(TS))]
12581pub struct GenerateSeries {
12582    #[serde(default)]
12583    pub start: Option<Box<Expression>>,
12584    #[serde(default)]
12585    pub end: Option<Box<Expression>>,
12586    #[serde(default)]
12587    pub step: Option<Box<Expression>>,
12588    #[serde(default)]
12589    pub is_end_exclusive: Option<Box<Expression>>,
12590}
12591
12592/// AIAgg
12593#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12594#[cfg_attr(feature = "bindings", derive(TS))]
12595pub struct AIAgg {
12596    pub this: Box<Expression>,
12597    pub expression: Box<Expression>,
12598}
12599
12600/// AIClassify
12601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12602#[cfg_attr(feature = "bindings", derive(TS))]
12603pub struct AIClassify {
12604    pub this: Box<Expression>,
12605    #[serde(default)]
12606    pub categories: Option<Box<Expression>>,
12607    #[serde(default)]
12608    pub config: Option<Box<Expression>>,
12609}
12610
12611/// ArrayAll
12612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12613#[cfg_attr(feature = "bindings", derive(TS))]
12614pub struct ArrayAll {
12615    pub this: Box<Expression>,
12616    pub expression: Box<Expression>,
12617}
12618
12619/// ArrayAny
12620#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12621#[cfg_attr(feature = "bindings", derive(TS))]
12622pub struct ArrayAny {
12623    pub this: Box<Expression>,
12624    pub expression: Box<Expression>,
12625}
12626
12627/// ArrayConstructCompact
12628#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12629#[cfg_attr(feature = "bindings", derive(TS))]
12630pub struct ArrayConstructCompact {
12631    #[serde(default)]
12632    pub expressions: Vec<Expression>,
12633}
12634
12635/// StPoint
12636#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12637#[cfg_attr(feature = "bindings", derive(TS))]
12638pub struct StPoint {
12639    pub this: Box<Expression>,
12640    pub expression: Box<Expression>,
12641    #[serde(default)]
12642    pub null: Option<Box<Expression>>,
12643}
12644
12645/// StDistance
12646#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12647#[cfg_attr(feature = "bindings", derive(TS))]
12648pub struct StDistance {
12649    pub this: Box<Expression>,
12650    pub expression: Box<Expression>,
12651    #[serde(default)]
12652    pub use_spheroid: Option<Box<Expression>>,
12653}
12654
12655/// StringToArray
12656#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12657#[cfg_attr(feature = "bindings", derive(TS))]
12658pub struct StringToArray {
12659    pub this: Box<Expression>,
12660    #[serde(default)]
12661    pub expression: Option<Box<Expression>>,
12662    #[serde(default)]
12663    pub null: Option<Box<Expression>>,
12664}
12665
12666/// ArraySum
12667#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12668#[cfg_attr(feature = "bindings", derive(TS))]
12669pub struct ArraySum {
12670    pub this: Box<Expression>,
12671    #[serde(default)]
12672    pub expression: Option<Box<Expression>>,
12673}
12674
12675/// ObjectAgg
12676#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12677#[cfg_attr(feature = "bindings", derive(TS))]
12678pub struct ObjectAgg {
12679    pub this: Box<Expression>,
12680    pub expression: Box<Expression>,
12681}
12682
12683/// CastToStrType
12684#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12685#[cfg_attr(feature = "bindings", derive(TS))]
12686pub struct CastToStrType {
12687    pub this: Box<Expression>,
12688    #[serde(default)]
12689    pub to: Option<Box<Expression>>,
12690}
12691
12692/// CheckJson
12693#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12694#[cfg_attr(feature = "bindings", derive(TS))]
12695pub struct CheckJson {
12696    pub this: Box<Expression>,
12697}
12698
12699/// CheckXml
12700#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12701#[cfg_attr(feature = "bindings", derive(TS))]
12702pub struct CheckXml {
12703    pub this: Box<Expression>,
12704    #[serde(default)]
12705    pub disable_auto_convert: Option<Box<Expression>>,
12706}
12707
12708/// TranslateCharacters
12709#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12710#[cfg_attr(feature = "bindings", derive(TS))]
12711pub struct TranslateCharacters {
12712    pub this: Box<Expression>,
12713    pub expression: Box<Expression>,
12714    #[serde(default)]
12715    pub with_error: Option<Box<Expression>>,
12716}
12717
12718/// CurrentSchemas
12719#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12720#[cfg_attr(feature = "bindings", derive(TS))]
12721pub struct CurrentSchemas {
12722    #[serde(default)]
12723    pub this: Option<Box<Expression>>,
12724}
12725
12726/// CurrentDatetime
12727#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12728#[cfg_attr(feature = "bindings", derive(TS))]
12729pub struct CurrentDatetime {
12730    #[serde(default)]
12731    pub this: Option<Box<Expression>>,
12732}
12733
12734/// Localtime
12735#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12736#[cfg_attr(feature = "bindings", derive(TS))]
12737pub struct Localtime {
12738    #[serde(default)]
12739    pub this: Option<Box<Expression>>,
12740}
12741
12742/// Localtimestamp
12743#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12744#[cfg_attr(feature = "bindings", derive(TS))]
12745pub struct Localtimestamp {
12746    #[serde(default)]
12747    pub this: Option<Box<Expression>>,
12748}
12749
12750/// Systimestamp
12751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12752#[cfg_attr(feature = "bindings", derive(TS))]
12753pub struct Systimestamp {
12754    #[serde(default)]
12755    pub this: Option<Box<Expression>>,
12756}
12757
12758/// CurrentSchema
12759#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12760#[cfg_attr(feature = "bindings", derive(TS))]
12761pub struct CurrentSchema {
12762    #[serde(default)]
12763    pub this: Option<Box<Expression>>,
12764}
12765
12766/// CurrentUser
12767#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12768#[cfg_attr(feature = "bindings", derive(TS))]
12769pub struct CurrentUser {
12770    #[serde(default)]
12771    pub this: Option<Box<Expression>>,
12772}
12773
12774/// SessionUser - MySQL/PostgreSQL SESSION_USER function
12775#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12776#[cfg_attr(feature = "bindings", derive(TS))]
12777pub struct SessionUser;
12778
12779/// JSONPathRoot - Represents $ in JSON path expressions
12780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12781#[cfg_attr(feature = "bindings", derive(TS))]
12782pub struct JSONPathRoot;
12783
12784/// UtcTime
12785#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12786#[cfg_attr(feature = "bindings", derive(TS))]
12787pub struct UtcTime {
12788    #[serde(default)]
12789    pub this: Option<Box<Expression>>,
12790}
12791
12792/// UtcTimestamp
12793#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12794#[cfg_attr(feature = "bindings", derive(TS))]
12795pub struct UtcTimestamp {
12796    #[serde(default)]
12797    pub this: Option<Box<Expression>>,
12798}
12799
12800/// TimestampFunc - TIMESTAMP constructor function
12801#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12802#[cfg_attr(feature = "bindings", derive(TS))]
12803pub struct TimestampFunc {
12804    #[serde(default)]
12805    pub this: Option<Box<Expression>>,
12806    #[serde(default)]
12807    pub zone: Option<Box<Expression>>,
12808    #[serde(default)]
12809    pub with_tz: Option<bool>,
12810    #[serde(default)]
12811    pub safe: Option<bool>,
12812}
12813
12814/// DateBin
12815#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12816#[cfg_attr(feature = "bindings", derive(TS))]
12817pub struct DateBin {
12818    pub this: Box<Expression>,
12819    pub expression: Box<Expression>,
12820    #[serde(default)]
12821    pub unit: Option<String>,
12822    #[serde(default)]
12823    pub zone: Option<Box<Expression>>,
12824    #[serde(default)]
12825    pub origin: Option<Box<Expression>>,
12826}
12827
12828/// Datetime
12829#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12830#[cfg_attr(feature = "bindings", derive(TS))]
12831pub struct Datetime {
12832    pub this: Box<Expression>,
12833    #[serde(default)]
12834    pub expression: Option<Box<Expression>>,
12835}
12836
12837/// DatetimeAdd
12838#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12839#[cfg_attr(feature = "bindings", derive(TS))]
12840pub struct DatetimeAdd {
12841    pub this: Box<Expression>,
12842    pub expression: Box<Expression>,
12843    #[serde(default)]
12844    pub unit: Option<String>,
12845}
12846
12847/// DatetimeSub
12848#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12849#[cfg_attr(feature = "bindings", derive(TS))]
12850pub struct DatetimeSub {
12851    pub this: Box<Expression>,
12852    pub expression: Box<Expression>,
12853    #[serde(default)]
12854    pub unit: Option<String>,
12855}
12856
12857/// DatetimeDiff
12858#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12859#[cfg_attr(feature = "bindings", derive(TS))]
12860pub struct DatetimeDiff {
12861    pub this: Box<Expression>,
12862    pub expression: Box<Expression>,
12863    #[serde(default)]
12864    pub unit: Option<String>,
12865}
12866
12867/// DatetimeTrunc
12868#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12869#[cfg_attr(feature = "bindings", derive(TS))]
12870pub struct DatetimeTrunc {
12871    pub this: Box<Expression>,
12872    pub unit: String,
12873    #[serde(default)]
12874    pub zone: Option<Box<Expression>>,
12875}
12876
12877/// Dayname
12878#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12879#[cfg_attr(feature = "bindings", derive(TS))]
12880pub struct Dayname {
12881    pub this: Box<Expression>,
12882    #[serde(default)]
12883    pub abbreviated: Option<Box<Expression>>,
12884}
12885
12886/// MakeInterval
12887#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12888#[cfg_attr(feature = "bindings", derive(TS))]
12889pub struct MakeInterval {
12890    #[serde(default)]
12891    pub year: Option<Box<Expression>>,
12892    #[serde(default)]
12893    pub month: Option<Box<Expression>>,
12894    #[serde(default)]
12895    pub week: Option<Box<Expression>>,
12896    #[serde(default)]
12897    pub day: Option<Box<Expression>>,
12898    #[serde(default)]
12899    pub hour: Option<Box<Expression>>,
12900    #[serde(default)]
12901    pub minute: Option<Box<Expression>>,
12902    #[serde(default)]
12903    pub second: Option<Box<Expression>>,
12904}
12905
12906/// PreviousDay
12907#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12908#[cfg_attr(feature = "bindings", derive(TS))]
12909pub struct PreviousDay {
12910    pub this: Box<Expression>,
12911    pub expression: Box<Expression>,
12912}
12913
12914/// Elt
12915#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12916#[cfg_attr(feature = "bindings", derive(TS))]
12917pub struct Elt {
12918    pub this: Box<Expression>,
12919    #[serde(default)]
12920    pub expressions: Vec<Expression>,
12921}
12922
12923/// TimestampAdd
12924#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12925#[cfg_attr(feature = "bindings", derive(TS))]
12926pub struct TimestampAdd {
12927    pub this: Box<Expression>,
12928    pub expression: Box<Expression>,
12929    #[serde(default)]
12930    pub unit: Option<String>,
12931}
12932
12933/// TimestampSub
12934#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12935#[cfg_attr(feature = "bindings", derive(TS))]
12936pub struct TimestampSub {
12937    pub this: Box<Expression>,
12938    pub expression: Box<Expression>,
12939    #[serde(default)]
12940    pub unit: Option<String>,
12941}
12942
12943/// TimestampDiff
12944#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12945#[cfg_attr(feature = "bindings", derive(TS))]
12946pub struct TimestampDiff {
12947    pub this: Box<Expression>,
12948    pub expression: Box<Expression>,
12949    #[serde(default)]
12950    pub unit: Option<String>,
12951}
12952
12953/// TimeSlice
12954#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12955#[cfg_attr(feature = "bindings", derive(TS))]
12956pub struct TimeSlice {
12957    pub this: Box<Expression>,
12958    pub expression: Box<Expression>,
12959    pub unit: String,
12960    #[serde(default)]
12961    pub kind: Option<String>,
12962}
12963
12964/// TimeAdd
12965#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12966#[cfg_attr(feature = "bindings", derive(TS))]
12967pub struct TimeAdd {
12968    pub this: Box<Expression>,
12969    pub expression: Box<Expression>,
12970    #[serde(default)]
12971    pub unit: Option<String>,
12972}
12973
12974/// TimeSub
12975#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12976#[cfg_attr(feature = "bindings", derive(TS))]
12977pub struct TimeSub {
12978    pub this: Box<Expression>,
12979    pub expression: Box<Expression>,
12980    #[serde(default)]
12981    pub unit: Option<String>,
12982}
12983
12984/// TimeDiff
12985#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12986#[cfg_attr(feature = "bindings", derive(TS))]
12987pub struct TimeDiff {
12988    pub this: Box<Expression>,
12989    pub expression: Box<Expression>,
12990    #[serde(default)]
12991    pub unit: Option<String>,
12992}
12993
12994/// TimeTrunc
12995#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12996#[cfg_attr(feature = "bindings", derive(TS))]
12997pub struct TimeTrunc {
12998    pub this: Box<Expression>,
12999    pub unit: String,
13000    #[serde(default)]
13001    pub zone: Option<Box<Expression>>,
13002}
13003
13004/// DateFromParts
13005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13006#[cfg_attr(feature = "bindings", derive(TS))]
13007pub struct DateFromParts {
13008    #[serde(default)]
13009    pub year: Option<Box<Expression>>,
13010    #[serde(default)]
13011    pub month: Option<Box<Expression>>,
13012    #[serde(default)]
13013    pub day: Option<Box<Expression>>,
13014    #[serde(default)]
13015    pub allow_overflow: Option<Box<Expression>>,
13016}
13017
13018/// TimeFromParts
13019#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13020#[cfg_attr(feature = "bindings", derive(TS))]
13021pub struct TimeFromParts {
13022    #[serde(default)]
13023    pub hour: Option<Box<Expression>>,
13024    #[serde(default)]
13025    pub min: Option<Box<Expression>>,
13026    #[serde(default)]
13027    pub sec: Option<Box<Expression>>,
13028    #[serde(default)]
13029    pub nano: Option<Box<Expression>>,
13030    #[serde(default)]
13031    pub fractions: Option<Box<Expression>>,
13032    #[serde(default)]
13033    pub precision: Option<i64>,
13034}
13035
13036/// DecodeCase
13037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13038#[cfg_attr(feature = "bindings", derive(TS))]
13039pub struct DecodeCase {
13040    #[serde(default)]
13041    pub expressions: Vec<Expression>,
13042}
13043
13044/// Decrypt
13045#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13046#[cfg_attr(feature = "bindings", derive(TS))]
13047pub struct Decrypt {
13048    pub this: Box<Expression>,
13049    #[serde(default)]
13050    pub passphrase: Option<Box<Expression>>,
13051    #[serde(default)]
13052    pub aad: Option<Box<Expression>>,
13053    #[serde(default)]
13054    pub encryption_method: Option<Box<Expression>>,
13055    #[serde(default)]
13056    pub safe: Option<Box<Expression>>,
13057}
13058
13059/// DecryptRaw
13060#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13061#[cfg_attr(feature = "bindings", derive(TS))]
13062pub struct DecryptRaw {
13063    pub this: Box<Expression>,
13064    #[serde(default)]
13065    pub key: Option<Box<Expression>>,
13066    #[serde(default)]
13067    pub iv: Option<Box<Expression>>,
13068    #[serde(default)]
13069    pub aad: Option<Box<Expression>>,
13070    #[serde(default)]
13071    pub encryption_method: Option<Box<Expression>>,
13072    #[serde(default)]
13073    pub aead: Option<Box<Expression>>,
13074    #[serde(default)]
13075    pub safe: Option<Box<Expression>>,
13076}
13077
13078/// Encode
13079#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13080#[cfg_attr(feature = "bindings", derive(TS))]
13081pub struct Encode {
13082    pub this: Box<Expression>,
13083    #[serde(default)]
13084    pub charset: Option<Box<Expression>>,
13085}
13086
13087/// Encrypt
13088#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13089#[cfg_attr(feature = "bindings", derive(TS))]
13090pub struct Encrypt {
13091    pub this: Box<Expression>,
13092    #[serde(default)]
13093    pub passphrase: Option<Box<Expression>>,
13094    #[serde(default)]
13095    pub aad: Option<Box<Expression>>,
13096    #[serde(default)]
13097    pub encryption_method: Option<Box<Expression>>,
13098}
13099
13100/// EncryptRaw
13101#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13102#[cfg_attr(feature = "bindings", derive(TS))]
13103pub struct EncryptRaw {
13104    pub this: Box<Expression>,
13105    #[serde(default)]
13106    pub key: Option<Box<Expression>>,
13107    #[serde(default)]
13108    pub iv: Option<Box<Expression>>,
13109    #[serde(default)]
13110    pub aad: Option<Box<Expression>>,
13111    #[serde(default)]
13112    pub encryption_method: Option<Box<Expression>>,
13113}
13114
13115/// EqualNull
13116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13117#[cfg_attr(feature = "bindings", derive(TS))]
13118pub struct EqualNull {
13119    pub this: Box<Expression>,
13120    pub expression: Box<Expression>,
13121}
13122
13123/// ToBinary
13124#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13125#[cfg_attr(feature = "bindings", derive(TS))]
13126pub struct ToBinary {
13127    pub this: Box<Expression>,
13128    #[serde(default)]
13129    pub format: Option<String>,
13130    #[serde(default)]
13131    pub safe: Option<Box<Expression>>,
13132}
13133
13134/// Base64DecodeBinary
13135#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13136#[cfg_attr(feature = "bindings", derive(TS))]
13137pub struct Base64DecodeBinary {
13138    pub this: Box<Expression>,
13139    #[serde(default)]
13140    pub alphabet: Option<Box<Expression>>,
13141}
13142
13143/// Base64DecodeString
13144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13145#[cfg_attr(feature = "bindings", derive(TS))]
13146pub struct Base64DecodeString {
13147    pub this: Box<Expression>,
13148    #[serde(default)]
13149    pub alphabet: Option<Box<Expression>>,
13150}
13151
13152/// Base64Encode
13153#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13154#[cfg_attr(feature = "bindings", derive(TS))]
13155pub struct Base64Encode {
13156    pub this: Box<Expression>,
13157    #[serde(default)]
13158    pub max_line_length: Option<Box<Expression>>,
13159    #[serde(default)]
13160    pub alphabet: Option<Box<Expression>>,
13161}
13162
13163/// TryBase64DecodeBinary
13164#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13165#[cfg_attr(feature = "bindings", derive(TS))]
13166pub struct TryBase64DecodeBinary {
13167    pub this: Box<Expression>,
13168    #[serde(default)]
13169    pub alphabet: Option<Box<Expression>>,
13170}
13171
13172/// TryBase64DecodeString
13173#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13174#[cfg_attr(feature = "bindings", derive(TS))]
13175pub struct TryBase64DecodeString {
13176    pub this: Box<Expression>,
13177    #[serde(default)]
13178    pub alphabet: Option<Box<Expression>>,
13179}
13180
13181/// GapFill
13182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13183#[cfg_attr(feature = "bindings", derive(TS))]
13184pub struct GapFill {
13185    pub this: Box<Expression>,
13186    #[serde(default)]
13187    pub ts_column: Option<Box<Expression>>,
13188    #[serde(default)]
13189    pub bucket_width: Option<Box<Expression>>,
13190    #[serde(default)]
13191    pub partitioning_columns: Option<Box<Expression>>,
13192    #[serde(default)]
13193    pub value_columns: Option<Box<Expression>>,
13194    #[serde(default)]
13195    pub origin: Option<Box<Expression>>,
13196    #[serde(default)]
13197    pub ignore_nulls: Option<Box<Expression>>,
13198}
13199
13200/// GenerateDateArray
13201#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13202#[cfg_attr(feature = "bindings", derive(TS))]
13203pub struct GenerateDateArray {
13204    #[serde(default)]
13205    pub start: Option<Box<Expression>>,
13206    #[serde(default)]
13207    pub end: Option<Box<Expression>>,
13208    #[serde(default)]
13209    pub step: Option<Box<Expression>>,
13210}
13211
13212/// GenerateTimestampArray
13213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13214#[cfg_attr(feature = "bindings", derive(TS))]
13215pub struct GenerateTimestampArray {
13216    #[serde(default)]
13217    pub start: Option<Box<Expression>>,
13218    #[serde(default)]
13219    pub end: Option<Box<Expression>>,
13220    #[serde(default)]
13221    pub step: Option<Box<Expression>>,
13222}
13223
13224/// GetExtract
13225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13226#[cfg_attr(feature = "bindings", derive(TS))]
13227pub struct GetExtract {
13228    pub this: Box<Expression>,
13229    pub expression: Box<Expression>,
13230}
13231
13232/// Getbit
13233#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13234#[cfg_attr(feature = "bindings", derive(TS))]
13235pub struct Getbit {
13236    pub this: Box<Expression>,
13237    pub expression: Box<Expression>,
13238    #[serde(default)]
13239    pub zero_is_msb: Option<Box<Expression>>,
13240}
13241
13242/// OverflowTruncateBehavior
13243#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13244#[cfg_attr(feature = "bindings", derive(TS))]
13245pub struct OverflowTruncateBehavior {
13246    #[serde(default)]
13247    pub this: Option<Box<Expression>>,
13248    #[serde(default)]
13249    pub with_count: Option<Box<Expression>>,
13250}
13251
13252/// HexEncode
13253#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13254#[cfg_attr(feature = "bindings", derive(TS))]
13255pub struct HexEncode {
13256    pub this: Box<Expression>,
13257    #[serde(default)]
13258    pub case: Option<Box<Expression>>,
13259}
13260
13261/// Compress
13262#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13263#[cfg_attr(feature = "bindings", derive(TS))]
13264pub struct Compress {
13265    pub this: Box<Expression>,
13266    #[serde(default)]
13267    pub method: Option<String>,
13268}
13269
13270/// DecompressBinary
13271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13272#[cfg_attr(feature = "bindings", derive(TS))]
13273pub struct DecompressBinary {
13274    pub this: Box<Expression>,
13275    pub method: String,
13276}
13277
13278/// DecompressString
13279#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13280#[cfg_attr(feature = "bindings", derive(TS))]
13281pub struct DecompressString {
13282    pub this: Box<Expression>,
13283    pub method: String,
13284}
13285
13286/// Xor
13287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13288#[cfg_attr(feature = "bindings", derive(TS))]
13289pub struct Xor {
13290    #[serde(default)]
13291    pub this: Option<Box<Expression>>,
13292    #[serde(default)]
13293    pub expression: Option<Box<Expression>>,
13294    #[serde(default)]
13295    pub expressions: Vec<Expression>,
13296}
13297
13298/// Nullif
13299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13300#[cfg_attr(feature = "bindings", derive(TS))]
13301pub struct Nullif {
13302    pub this: Box<Expression>,
13303    pub expression: Box<Expression>,
13304}
13305
13306/// JSON
13307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13308#[cfg_attr(feature = "bindings", derive(TS))]
13309pub struct JSON {
13310    #[serde(default)]
13311    pub this: Option<Box<Expression>>,
13312    #[serde(default)]
13313    pub with_: Option<Box<Expression>>,
13314    #[serde(default)]
13315    pub unique: bool,
13316}
13317
13318/// JSONPath
13319#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13320#[cfg_attr(feature = "bindings", derive(TS))]
13321pub struct JSONPath {
13322    #[serde(default)]
13323    pub expressions: Vec<Expression>,
13324    #[serde(default)]
13325    pub escape: Option<Box<Expression>>,
13326}
13327
13328/// JSONPathFilter
13329#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13330#[cfg_attr(feature = "bindings", derive(TS))]
13331pub struct JSONPathFilter {
13332    pub this: Box<Expression>,
13333}
13334
13335/// JSONPathKey
13336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13337#[cfg_attr(feature = "bindings", derive(TS))]
13338pub struct JSONPathKey {
13339    pub this: Box<Expression>,
13340}
13341
13342/// JSONPathRecursive
13343#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13344#[cfg_attr(feature = "bindings", derive(TS))]
13345pub struct JSONPathRecursive {
13346    #[serde(default)]
13347    pub this: Option<Box<Expression>>,
13348}
13349
13350/// JSONPathScript
13351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13352#[cfg_attr(feature = "bindings", derive(TS))]
13353pub struct JSONPathScript {
13354    pub this: Box<Expression>,
13355}
13356
13357/// JSONPathSlice
13358#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13359#[cfg_attr(feature = "bindings", derive(TS))]
13360pub struct JSONPathSlice {
13361    #[serde(default)]
13362    pub start: Option<Box<Expression>>,
13363    #[serde(default)]
13364    pub end: Option<Box<Expression>>,
13365    #[serde(default)]
13366    pub step: Option<Box<Expression>>,
13367}
13368
13369/// JSONPathSelector
13370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13371#[cfg_attr(feature = "bindings", derive(TS))]
13372pub struct JSONPathSelector {
13373    pub this: Box<Expression>,
13374}
13375
13376/// JSONPathSubscript
13377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13378#[cfg_attr(feature = "bindings", derive(TS))]
13379pub struct JSONPathSubscript {
13380    pub this: Box<Expression>,
13381}
13382
13383/// JSONPathUnion
13384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13385#[cfg_attr(feature = "bindings", derive(TS))]
13386pub struct JSONPathUnion {
13387    #[serde(default)]
13388    pub expressions: Vec<Expression>,
13389}
13390
13391/// Format
13392#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13393#[cfg_attr(feature = "bindings", derive(TS))]
13394pub struct Format {
13395    pub this: Box<Expression>,
13396    #[serde(default)]
13397    pub expressions: Vec<Expression>,
13398}
13399
13400/// JSONKeys
13401#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13402#[cfg_attr(feature = "bindings", derive(TS))]
13403pub struct JSONKeys {
13404    pub this: Box<Expression>,
13405    #[serde(default)]
13406    pub expression: Option<Box<Expression>>,
13407    #[serde(default)]
13408    pub expressions: Vec<Expression>,
13409}
13410
13411/// JSONKeyValue
13412#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13413#[cfg_attr(feature = "bindings", derive(TS))]
13414pub struct JSONKeyValue {
13415    pub this: Box<Expression>,
13416    pub expression: Box<Expression>,
13417}
13418
13419/// JSONKeysAtDepth
13420#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13421#[cfg_attr(feature = "bindings", derive(TS))]
13422pub struct JSONKeysAtDepth {
13423    pub this: Box<Expression>,
13424    #[serde(default)]
13425    pub expression: Option<Box<Expression>>,
13426    #[serde(default)]
13427    pub mode: Option<Box<Expression>>,
13428}
13429
13430/// JSONObject
13431#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13432#[cfg_attr(feature = "bindings", derive(TS))]
13433pub struct JSONObject {
13434    #[serde(default)]
13435    pub expressions: Vec<Expression>,
13436    #[serde(default)]
13437    pub null_handling: Option<Box<Expression>>,
13438    #[serde(default)]
13439    pub unique_keys: Option<Box<Expression>>,
13440    #[serde(default)]
13441    pub return_type: Option<Box<Expression>>,
13442    #[serde(default)]
13443    pub encoding: Option<Box<Expression>>,
13444}
13445
13446/// JSONObjectAgg
13447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13448#[cfg_attr(feature = "bindings", derive(TS))]
13449pub struct JSONObjectAgg {
13450    #[serde(default)]
13451    pub expressions: Vec<Expression>,
13452    #[serde(default)]
13453    pub null_handling: Option<Box<Expression>>,
13454    #[serde(default)]
13455    pub unique_keys: Option<Box<Expression>>,
13456    #[serde(default)]
13457    pub return_type: Option<Box<Expression>>,
13458    #[serde(default)]
13459    pub encoding: Option<Box<Expression>>,
13460}
13461
13462/// JSONBObjectAgg
13463#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13464#[cfg_attr(feature = "bindings", derive(TS))]
13465pub struct JSONBObjectAgg {
13466    pub this: Box<Expression>,
13467    pub expression: Box<Expression>,
13468}
13469
13470/// JSONArray
13471#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13472#[cfg_attr(feature = "bindings", derive(TS))]
13473pub struct JSONArray {
13474    #[serde(default)]
13475    pub expressions: Vec<Expression>,
13476    #[serde(default)]
13477    pub null_handling: Option<Box<Expression>>,
13478    #[serde(default)]
13479    pub return_type: Option<Box<Expression>>,
13480    #[serde(default)]
13481    pub strict: Option<Box<Expression>>,
13482}
13483
13484/// JSONArrayAgg
13485#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13486#[cfg_attr(feature = "bindings", derive(TS))]
13487pub struct JSONArrayAgg {
13488    pub this: Box<Expression>,
13489    #[serde(default)]
13490    pub order: Option<Box<Expression>>,
13491    #[serde(default)]
13492    pub null_handling: Option<Box<Expression>>,
13493    #[serde(default)]
13494    pub return_type: Option<Box<Expression>>,
13495    #[serde(default)]
13496    pub strict: Option<Box<Expression>>,
13497}
13498
13499/// JSONExists
13500#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13501#[cfg_attr(feature = "bindings", derive(TS))]
13502pub struct JSONExists {
13503    pub this: Box<Expression>,
13504    #[serde(default)]
13505    pub path: Option<Box<Expression>>,
13506    #[serde(default)]
13507    pub passing: Option<Box<Expression>>,
13508    #[serde(default)]
13509    pub on_condition: Option<Box<Expression>>,
13510    #[serde(default)]
13511    pub from_dcolonqmark: Option<Box<Expression>>,
13512}
13513
13514/// JSONColumnDef
13515#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13516#[cfg_attr(feature = "bindings", derive(TS))]
13517pub struct JSONColumnDef {
13518    #[serde(default)]
13519    pub this: Option<Box<Expression>>,
13520    #[serde(default)]
13521    pub kind: Option<String>,
13522    #[serde(default)]
13523    pub path: Option<Box<Expression>>,
13524    #[serde(default)]
13525    pub nested_schema: Option<Box<Expression>>,
13526    #[serde(default)]
13527    pub ordinality: Option<Box<Expression>>,
13528}
13529
13530/// JSONSchema
13531#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13532#[cfg_attr(feature = "bindings", derive(TS))]
13533pub struct JSONSchema {
13534    #[serde(default)]
13535    pub expressions: Vec<Expression>,
13536}
13537
13538/// JSONSet
13539#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13540#[cfg_attr(feature = "bindings", derive(TS))]
13541pub struct JSONSet {
13542    pub this: Box<Expression>,
13543    #[serde(default)]
13544    pub expressions: Vec<Expression>,
13545}
13546
13547/// JSONStripNulls
13548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13549#[cfg_attr(feature = "bindings", derive(TS))]
13550pub struct JSONStripNulls {
13551    pub this: Box<Expression>,
13552    #[serde(default)]
13553    pub expression: Option<Box<Expression>>,
13554    #[serde(default)]
13555    pub include_arrays: Option<Box<Expression>>,
13556    #[serde(default)]
13557    pub remove_empty: Option<Box<Expression>>,
13558}
13559
13560/// JSONValue
13561#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13562#[cfg_attr(feature = "bindings", derive(TS))]
13563pub struct JSONValue {
13564    pub this: Box<Expression>,
13565    #[serde(default)]
13566    pub path: Option<Box<Expression>>,
13567    #[serde(default)]
13568    pub returning: Option<Box<Expression>>,
13569    #[serde(default)]
13570    pub on_condition: Option<Box<Expression>>,
13571}
13572
13573/// JSONValueArray
13574#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13575#[cfg_attr(feature = "bindings", derive(TS))]
13576pub struct JSONValueArray {
13577    pub this: Box<Expression>,
13578    #[serde(default)]
13579    pub expression: Option<Box<Expression>>,
13580}
13581
13582/// JSONRemove
13583#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13584#[cfg_attr(feature = "bindings", derive(TS))]
13585pub struct JSONRemove {
13586    pub this: Box<Expression>,
13587    #[serde(default)]
13588    pub expressions: Vec<Expression>,
13589}
13590
13591/// JSONTable
13592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13593#[cfg_attr(feature = "bindings", derive(TS))]
13594pub struct JSONTable {
13595    pub this: Box<Expression>,
13596    #[serde(default)]
13597    pub schema: Option<Box<Expression>>,
13598    #[serde(default)]
13599    pub path: Option<Box<Expression>>,
13600    #[serde(default)]
13601    pub error_handling: Option<Box<Expression>>,
13602    #[serde(default)]
13603    pub empty_handling: Option<Box<Expression>>,
13604}
13605
13606/// JSONType
13607#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13608#[cfg_attr(feature = "bindings", derive(TS))]
13609pub struct JSONType {
13610    pub this: Box<Expression>,
13611    #[serde(default)]
13612    pub expression: Option<Box<Expression>>,
13613}
13614
13615/// ObjectInsert
13616#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13617#[cfg_attr(feature = "bindings", derive(TS))]
13618pub struct ObjectInsert {
13619    pub this: Box<Expression>,
13620    #[serde(default)]
13621    pub key: Option<Box<Expression>>,
13622    #[serde(default)]
13623    pub value: Option<Box<Expression>>,
13624    #[serde(default)]
13625    pub update_flag: Option<Box<Expression>>,
13626}
13627
13628/// OpenJSONColumnDef
13629#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13630#[cfg_attr(feature = "bindings", derive(TS))]
13631pub struct OpenJSONColumnDef {
13632    pub this: Box<Expression>,
13633    pub kind: String,
13634    #[serde(default)]
13635    pub path: Option<Box<Expression>>,
13636    #[serde(default)]
13637    pub as_json: Option<Box<Expression>>,
13638    /// The parsed data type for proper generation
13639    #[serde(default, skip_serializing_if = "Option::is_none")]
13640    pub data_type: Option<DataType>,
13641}
13642
13643/// OpenJSON
13644#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13645#[cfg_attr(feature = "bindings", derive(TS))]
13646pub struct OpenJSON {
13647    pub this: Box<Expression>,
13648    #[serde(default)]
13649    pub path: Option<Box<Expression>>,
13650    #[serde(default)]
13651    pub expressions: Vec<Expression>,
13652}
13653
13654/// JSONBExists
13655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13656#[cfg_attr(feature = "bindings", derive(TS))]
13657pub struct JSONBExists {
13658    pub this: Box<Expression>,
13659    #[serde(default)]
13660    pub path: Option<Box<Expression>>,
13661}
13662
13663/// JSONCast
13664#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13665#[cfg_attr(feature = "bindings", derive(TS))]
13666pub struct JSONCast {
13667    pub this: Box<Expression>,
13668    pub to: DataType,
13669}
13670
13671/// JSONExtract
13672#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13673#[cfg_attr(feature = "bindings", derive(TS))]
13674pub struct JSONExtract {
13675    pub this: Box<Expression>,
13676    pub expression: Box<Expression>,
13677    #[serde(default)]
13678    pub only_json_types: Option<Box<Expression>>,
13679    #[serde(default)]
13680    pub expressions: Vec<Expression>,
13681    #[serde(default)]
13682    pub variant_extract: Option<Box<Expression>>,
13683    #[serde(default)]
13684    pub json_query: Option<Box<Expression>>,
13685    #[serde(default)]
13686    pub option: Option<Box<Expression>>,
13687    #[serde(default)]
13688    pub quote: Option<Box<Expression>>,
13689    #[serde(default)]
13690    pub on_condition: Option<Box<Expression>>,
13691    #[serde(default)]
13692    pub requires_json: Option<Box<Expression>>,
13693}
13694
13695/// JSONExtractQuote
13696#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13697#[cfg_attr(feature = "bindings", derive(TS))]
13698pub struct JSONExtractQuote {
13699    #[serde(default)]
13700    pub option: Option<Box<Expression>>,
13701    #[serde(default)]
13702    pub scalar: Option<Box<Expression>>,
13703}
13704
13705/// JSONExtractArray
13706#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13707#[cfg_attr(feature = "bindings", derive(TS))]
13708pub struct JSONExtractArray {
13709    pub this: Box<Expression>,
13710    #[serde(default)]
13711    pub expression: Option<Box<Expression>>,
13712}
13713
13714/// JSONExtractScalar
13715#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13716#[cfg_attr(feature = "bindings", derive(TS))]
13717pub struct JSONExtractScalar {
13718    pub this: Box<Expression>,
13719    pub expression: Box<Expression>,
13720    #[serde(default)]
13721    pub only_json_types: Option<Box<Expression>>,
13722    #[serde(default)]
13723    pub expressions: Vec<Expression>,
13724    #[serde(default)]
13725    pub json_type: Option<Box<Expression>>,
13726    #[serde(default)]
13727    pub scalar_only: Option<Box<Expression>>,
13728}
13729
13730/// JSONBExtractScalar
13731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13732#[cfg_attr(feature = "bindings", derive(TS))]
13733pub struct JSONBExtractScalar {
13734    pub this: Box<Expression>,
13735    pub expression: Box<Expression>,
13736    #[serde(default)]
13737    pub json_type: Option<Box<Expression>>,
13738}
13739
13740/// JSONFormat
13741#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13742#[cfg_attr(feature = "bindings", derive(TS))]
13743pub struct JSONFormat {
13744    #[serde(default)]
13745    pub this: Option<Box<Expression>>,
13746    #[serde(default)]
13747    pub options: Vec<Expression>,
13748    #[serde(default)]
13749    pub is_json: Option<Box<Expression>>,
13750    #[serde(default)]
13751    pub to_json: Option<Box<Expression>>,
13752}
13753
13754/// JSONArrayAppend
13755#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13756#[cfg_attr(feature = "bindings", derive(TS))]
13757pub struct JSONArrayAppend {
13758    pub this: Box<Expression>,
13759    #[serde(default)]
13760    pub expressions: Vec<Expression>,
13761}
13762
13763/// JSONArrayContains
13764#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13765#[cfg_attr(feature = "bindings", derive(TS))]
13766pub struct JSONArrayContains {
13767    pub this: Box<Expression>,
13768    pub expression: Box<Expression>,
13769    #[serde(default)]
13770    pub json_type: Option<Box<Expression>>,
13771}
13772
13773/// JSONArrayInsert
13774#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13775#[cfg_attr(feature = "bindings", derive(TS))]
13776pub struct JSONArrayInsert {
13777    pub this: Box<Expression>,
13778    #[serde(default)]
13779    pub expressions: Vec<Expression>,
13780}
13781
13782/// ParseJSON
13783#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13784#[cfg_attr(feature = "bindings", derive(TS))]
13785pub struct ParseJSON {
13786    pub this: Box<Expression>,
13787    #[serde(default)]
13788    pub expression: Option<Box<Expression>>,
13789    #[serde(default)]
13790    pub safe: Option<Box<Expression>>,
13791}
13792
13793/// ParseUrl
13794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13795#[cfg_attr(feature = "bindings", derive(TS))]
13796pub struct ParseUrl {
13797    pub this: Box<Expression>,
13798    #[serde(default)]
13799    pub part_to_extract: Option<Box<Expression>>,
13800    #[serde(default)]
13801    pub key: Option<Box<Expression>>,
13802    #[serde(default)]
13803    pub permissive: Option<Box<Expression>>,
13804}
13805
13806/// ParseIp
13807#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13808#[cfg_attr(feature = "bindings", derive(TS))]
13809pub struct ParseIp {
13810    pub this: Box<Expression>,
13811    #[serde(default)]
13812    pub type_: Option<Box<Expression>>,
13813    #[serde(default)]
13814    pub permissive: Option<Box<Expression>>,
13815}
13816
13817/// ParseTime
13818#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13819#[cfg_attr(feature = "bindings", derive(TS))]
13820pub struct ParseTime {
13821    pub this: Box<Expression>,
13822    pub format: String,
13823}
13824
13825/// ParseDatetime
13826#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13827#[cfg_attr(feature = "bindings", derive(TS))]
13828pub struct ParseDatetime {
13829    pub this: Box<Expression>,
13830    #[serde(default)]
13831    pub format: Option<String>,
13832    #[serde(default)]
13833    pub zone: Option<Box<Expression>>,
13834}
13835
13836/// Map
13837#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13838#[cfg_attr(feature = "bindings", derive(TS))]
13839pub struct Map {
13840    #[serde(default)]
13841    pub keys: Vec<Expression>,
13842    #[serde(default)]
13843    pub values: Vec<Expression>,
13844}
13845
13846/// MapCat
13847#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13848#[cfg_attr(feature = "bindings", derive(TS))]
13849pub struct MapCat {
13850    pub this: Box<Expression>,
13851    pub expression: Box<Expression>,
13852}
13853
13854/// MapDelete
13855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13856#[cfg_attr(feature = "bindings", derive(TS))]
13857pub struct MapDelete {
13858    pub this: Box<Expression>,
13859    #[serde(default)]
13860    pub expressions: Vec<Expression>,
13861}
13862
13863/// MapInsert
13864#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13865#[cfg_attr(feature = "bindings", derive(TS))]
13866pub struct MapInsert {
13867    pub this: Box<Expression>,
13868    #[serde(default)]
13869    pub key: Option<Box<Expression>>,
13870    #[serde(default)]
13871    pub value: Option<Box<Expression>>,
13872    #[serde(default)]
13873    pub update_flag: Option<Box<Expression>>,
13874}
13875
13876/// MapPick
13877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13878#[cfg_attr(feature = "bindings", derive(TS))]
13879pub struct MapPick {
13880    pub this: Box<Expression>,
13881    #[serde(default)]
13882    pub expressions: Vec<Expression>,
13883}
13884
13885/// ScopeResolution
13886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13887#[cfg_attr(feature = "bindings", derive(TS))]
13888pub struct ScopeResolution {
13889    #[serde(default)]
13890    pub this: Option<Box<Expression>>,
13891    pub expression: Box<Expression>,
13892}
13893
13894/// Slice
13895#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13896#[cfg_attr(feature = "bindings", derive(TS))]
13897pub struct Slice {
13898    #[serde(default)]
13899    pub this: Option<Box<Expression>>,
13900    #[serde(default)]
13901    pub expression: Option<Box<Expression>>,
13902    #[serde(default)]
13903    pub step: Option<Box<Expression>>,
13904}
13905
13906/// VarMap
13907#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13908#[cfg_attr(feature = "bindings", derive(TS))]
13909pub struct VarMap {
13910    #[serde(default)]
13911    pub keys: Vec<Expression>,
13912    #[serde(default)]
13913    pub values: Vec<Expression>,
13914}
13915
13916/// MatchAgainst
13917#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13918#[cfg_attr(feature = "bindings", derive(TS))]
13919pub struct MatchAgainst {
13920    pub this: Box<Expression>,
13921    #[serde(default)]
13922    pub expressions: Vec<Expression>,
13923    #[serde(default)]
13924    pub modifier: Option<Box<Expression>>,
13925}
13926
13927/// MD5Digest
13928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13929#[cfg_attr(feature = "bindings", derive(TS))]
13930pub struct MD5Digest {
13931    pub this: Box<Expression>,
13932    #[serde(default)]
13933    pub expressions: Vec<Expression>,
13934}
13935
13936/// Monthname
13937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13938#[cfg_attr(feature = "bindings", derive(TS))]
13939pub struct Monthname {
13940    pub this: Box<Expression>,
13941    #[serde(default)]
13942    pub abbreviated: Option<Box<Expression>>,
13943}
13944
13945/// Ntile
13946#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13947#[cfg_attr(feature = "bindings", derive(TS))]
13948pub struct Ntile {
13949    #[serde(default)]
13950    pub this: Option<Box<Expression>>,
13951}
13952
13953/// Normalize
13954#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13955#[cfg_attr(feature = "bindings", derive(TS))]
13956pub struct Normalize {
13957    pub this: Box<Expression>,
13958    #[serde(default)]
13959    pub form: Option<Box<Expression>>,
13960    #[serde(default)]
13961    pub is_casefold: Option<Box<Expression>>,
13962}
13963
13964/// Normal
13965#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13966#[cfg_attr(feature = "bindings", derive(TS))]
13967pub struct Normal {
13968    pub this: Box<Expression>,
13969    #[serde(default)]
13970    pub stddev: Option<Box<Expression>>,
13971    #[serde(default)]
13972    pub gen: Option<Box<Expression>>,
13973}
13974
13975/// Predict
13976#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13977#[cfg_attr(feature = "bindings", derive(TS))]
13978pub struct Predict {
13979    pub this: Box<Expression>,
13980    pub expression: Box<Expression>,
13981    #[serde(default)]
13982    pub params_struct: Option<Box<Expression>>,
13983}
13984
13985/// MLTranslate
13986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13987#[cfg_attr(feature = "bindings", derive(TS))]
13988pub struct MLTranslate {
13989    pub this: Box<Expression>,
13990    pub expression: Box<Expression>,
13991    #[serde(default)]
13992    pub params_struct: Option<Box<Expression>>,
13993}
13994
13995/// FeaturesAtTime
13996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
13997#[cfg_attr(feature = "bindings", derive(TS))]
13998pub struct FeaturesAtTime {
13999    pub this: Box<Expression>,
14000    #[serde(default)]
14001    pub time: Option<Box<Expression>>,
14002    #[serde(default)]
14003    pub num_rows: Option<Box<Expression>>,
14004    #[serde(default)]
14005    pub ignore_feature_nulls: Option<Box<Expression>>,
14006}
14007
14008/// GenerateEmbedding
14009#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14010#[cfg_attr(feature = "bindings", derive(TS))]
14011pub struct GenerateEmbedding {
14012    pub this: Box<Expression>,
14013    pub expression: Box<Expression>,
14014    #[serde(default)]
14015    pub params_struct: Option<Box<Expression>>,
14016    #[serde(default)]
14017    pub is_text: Option<Box<Expression>>,
14018}
14019
14020/// MLForecast
14021#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14022#[cfg_attr(feature = "bindings", derive(TS))]
14023pub struct MLForecast {
14024    pub this: Box<Expression>,
14025    #[serde(default)]
14026    pub expression: Option<Box<Expression>>,
14027    #[serde(default)]
14028    pub params_struct: Option<Box<Expression>>,
14029}
14030
14031/// ModelAttribute
14032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14033#[cfg_attr(feature = "bindings", derive(TS))]
14034pub struct ModelAttribute {
14035    pub this: Box<Expression>,
14036    pub expression: Box<Expression>,
14037}
14038
14039/// VectorSearch
14040#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14041#[cfg_attr(feature = "bindings", derive(TS))]
14042pub struct VectorSearch {
14043    pub this: Box<Expression>,
14044    #[serde(default)]
14045    pub column_to_search: Option<Box<Expression>>,
14046    #[serde(default)]
14047    pub query_table: Option<Box<Expression>>,
14048    #[serde(default)]
14049    pub query_column_to_search: Option<Box<Expression>>,
14050    #[serde(default)]
14051    pub top_k: Option<Box<Expression>>,
14052    #[serde(default)]
14053    pub distance_type: Option<Box<Expression>>,
14054    #[serde(default)]
14055    pub options: Vec<Expression>,
14056}
14057
14058/// Quantile
14059#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14060#[cfg_attr(feature = "bindings", derive(TS))]
14061pub struct Quantile {
14062    pub this: Box<Expression>,
14063    #[serde(default)]
14064    pub quantile: Option<Box<Expression>>,
14065}
14066
14067/// ApproxQuantile
14068#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14069#[cfg_attr(feature = "bindings", derive(TS))]
14070pub struct ApproxQuantile {
14071    pub this: Box<Expression>,
14072    #[serde(default)]
14073    pub quantile: Option<Box<Expression>>,
14074    #[serde(default)]
14075    pub accuracy: Option<Box<Expression>>,
14076    #[serde(default)]
14077    pub weight: Option<Box<Expression>>,
14078    #[serde(default)]
14079    pub error_tolerance: Option<Box<Expression>>,
14080}
14081
14082/// ApproxPercentileEstimate
14083#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14084#[cfg_attr(feature = "bindings", derive(TS))]
14085pub struct ApproxPercentileEstimate {
14086    pub this: Box<Expression>,
14087    #[serde(default)]
14088    pub percentile: Option<Box<Expression>>,
14089}
14090
14091/// Randn
14092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14093#[cfg_attr(feature = "bindings", derive(TS))]
14094pub struct Randn {
14095    #[serde(default)]
14096    pub this: Option<Box<Expression>>,
14097}
14098
14099/// Randstr
14100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14101#[cfg_attr(feature = "bindings", derive(TS))]
14102pub struct Randstr {
14103    pub this: Box<Expression>,
14104    #[serde(default)]
14105    pub generator: Option<Box<Expression>>,
14106}
14107
14108/// RangeN
14109#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14110#[cfg_attr(feature = "bindings", derive(TS))]
14111pub struct RangeN {
14112    pub this: Box<Expression>,
14113    #[serde(default)]
14114    pub expressions: Vec<Expression>,
14115    #[serde(default)]
14116    pub each: Option<Box<Expression>>,
14117}
14118
14119/// RangeBucket
14120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14121#[cfg_attr(feature = "bindings", derive(TS))]
14122pub struct RangeBucket {
14123    pub this: Box<Expression>,
14124    pub expression: Box<Expression>,
14125}
14126
14127/// ReadCSV
14128#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14129#[cfg_attr(feature = "bindings", derive(TS))]
14130pub struct ReadCSV {
14131    pub this: Box<Expression>,
14132    #[serde(default)]
14133    pub expressions: Vec<Expression>,
14134}
14135
14136/// ReadParquet
14137#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14138#[cfg_attr(feature = "bindings", derive(TS))]
14139pub struct ReadParquet {
14140    #[serde(default)]
14141    pub expressions: Vec<Expression>,
14142}
14143
14144/// Reduce
14145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14146#[cfg_attr(feature = "bindings", derive(TS))]
14147pub struct Reduce {
14148    pub this: Box<Expression>,
14149    #[serde(default)]
14150    pub initial: Option<Box<Expression>>,
14151    #[serde(default)]
14152    pub merge: Option<Box<Expression>>,
14153    #[serde(default)]
14154    pub finish: Option<Box<Expression>>,
14155}
14156
14157/// RegexpExtractAll
14158#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14159#[cfg_attr(feature = "bindings", derive(TS))]
14160pub struct RegexpExtractAll {
14161    pub this: Box<Expression>,
14162    pub expression: Box<Expression>,
14163    #[serde(default)]
14164    pub group: Option<Box<Expression>>,
14165    #[serde(default)]
14166    pub parameters: Option<Box<Expression>>,
14167    #[serde(default)]
14168    pub position: Option<Box<Expression>>,
14169    #[serde(default)]
14170    pub occurrence: Option<Box<Expression>>,
14171}
14172
14173/// RegexpILike
14174#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14175#[cfg_attr(feature = "bindings", derive(TS))]
14176pub struct RegexpILike {
14177    pub this: Box<Expression>,
14178    pub expression: Box<Expression>,
14179    #[serde(default)]
14180    pub flag: Option<Box<Expression>>,
14181}
14182
14183/// RegexpFullMatch
14184#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14185#[cfg_attr(feature = "bindings", derive(TS))]
14186pub struct RegexpFullMatch {
14187    pub this: Box<Expression>,
14188    pub expression: Box<Expression>,
14189    #[serde(default)]
14190    pub options: Vec<Expression>,
14191}
14192
14193/// RegexpInstr
14194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14195#[cfg_attr(feature = "bindings", derive(TS))]
14196pub struct RegexpInstr {
14197    pub this: Box<Expression>,
14198    pub expression: Box<Expression>,
14199    #[serde(default)]
14200    pub position: Option<Box<Expression>>,
14201    #[serde(default)]
14202    pub occurrence: Option<Box<Expression>>,
14203    #[serde(default)]
14204    pub option: Option<Box<Expression>>,
14205    #[serde(default)]
14206    pub parameters: Option<Box<Expression>>,
14207    #[serde(default)]
14208    pub group: Option<Box<Expression>>,
14209}
14210
14211/// RegexpSplit
14212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14213#[cfg_attr(feature = "bindings", derive(TS))]
14214pub struct RegexpSplit {
14215    pub this: Box<Expression>,
14216    pub expression: Box<Expression>,
14217    #[serde(default)]
14218    pub limit: Option<Box<Expression>>,
14219}
14220
14221/// RegexpCount
14222#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14223#[cfg_attr(feature = "bindings", derive(TS))]
14224pub struct RegexpCount {
14225    pub this: Box<Expression>,
14226    pub expression: Box<Expression>,
14227    #[serde(default)]
14228    pub position: Option<Box<Expression>>,
14229    #[serde(default)]
14230    pub parameters: Option<Box<Expression>>,
14231}
14232
14233/// RegrValx
14234#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14235#[cfg_attr(feature = "bindings", derive(TS))]
14236pub struct RegrValx {
14237    pub this: Box<Expression>,
14238    pub expression: Box<Expression>,
14239}
14240
14241/// RegrValy
14242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14243#[cfg_attr(feature = "bindings", derive(TS))]
14244pub struct RegrValy {
14245    pub this: Box<Expression>,
14246    pub expression: Box<Expression>,
14247}
14248
14249/// RegrAvgy
14250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14251#[cfg_attr(feature = "bindings", derive(TS))]
14252pub struct RegrAvgy {
14253    pub this: Box<Expression>,
14254    pub expression: Box<Expression>,
14255}
14256
14257/// RegrAvgx
14258#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14259#[cfg_attr(feature = "bindings", derive(TS))]
14260pub struct RegrAvgx {
14261    pub this: Box<Expression>,
14262    pub expression: Box<Expression>,
14263}
14264
14265/// RegrCount
14266#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14267#[cfg_attr(feature = "bindings", derive(TS))]
14268pub struct RegrCount {
14269    pub this: Box<Expression>,
14270    pub expression: Box<Expression>,
14271}
14272
14273/// RegrIntercept
14274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14275#[cfg_attr(feature = "bindings", derive(TS))]
14276pub struct RegrIntercept {
14277    pub this: Box<Expression>,
14278    pub expression: Box<Expression>,
14279}
14280
14281/// RegrR2
14282#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14283#[cfg_attr(feature = "bindings", derive(TS))]
14284pub struct RegrR2 {
14285    pub this: Box<Expression>,
14286    pub expression: Box<Expression>,
14287}
14288
14289/// RegrSxx
14290#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14291#[cfg_attr(feature = "bindings", derive(TS))]
14292pub struct RegrSxx {
14293    pub this: Box<Expression>,
14294    pub expression: Box<Expression>,
14295}
14296
14297/// RegrSxy
14298#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14299#[cfg_attr(feature = "bindings", derive(TS))]
14300pub struct RegrSxy {
14301    pub this: Box<Expression>,
14302    pub expression: Box<Expression>,
14303}
14304
14305/// RegrSyy
14306#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14307#[cfg_attr(feature = "bindings", derive(TS))]
14308pub struct RegrSyy {
14309    pub this: Box<Expression>,
14310    pub expression: Box<Expression>,
14311}
14312
14313/// RegrSlope
14314#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14315#[cfg_attr(feature = "bindings", derive(TS))]
14316pub struct RegrSlope {
14317    pub this: Box<Expression>,
14318    pub expression: Box<Expression>,
14319}
14320
14321/// SafeAdd
14322#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14323#[cfg_attr(feature = "bindings", derive(TS))]
14324pub struct SafeAdd {
14325    pub this: Box<Expression>,
14326    pub expression: Box<Expression>,
14327}
14328
14329/// SafeDivide
14330#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14331#[cfg_attr(feature = "bindings", derive(TS))]
14332pub struct SafeDivide {
14333    pub this: Box<Expression>,
14334    pub expression: Box<Expression>,
14335}
14336
14337/// SafeMultiply
14338#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14339#[cfg_attr(feature = "bindings", derive(TS))]
14340pub struct SafeMultiply {
14341    pub this: Box<Expression>,
14342    pub expression: Box<Expression>,
14343}
14344
14345/// SafeSubtract
14346#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14347#[cfg_attr(feature = "bindings", derive(TS))]
14348pub struct SafeSubtract {
14349    pub this: Box<Expression>,
14350    pub expression: Box<Expression>,
14351}
14352
14353/// SHA2
14354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14355#[cfg_attr(feature = "bindings", derive(TS))]
14356pub struct SHA2 {
14357    pub this: Box<Expression>,
14358    #[serde(default)]
14359    pub length: Option<i64>,
14360}
14361
14362/// SHA2Digest
14363#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14364#[cfg_attr(feature = "bindings", derive(TS))]
14365pub struct SHA2Digest {
14366    pub this: Box<Expression>,
14367    #[serde(default)]
14368    pub length: Option<i64>,
14369}
14370
14371/// SortArray
14372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14373#[cfg_attr(feature = "bindings", derive(TS))]
14374pub struct SortArray {
14375    pub this: Box<Expression>,
14376    #[serde(default)]
14377    pub asc: Option<Box<Expression>>,
14378    #[serde(default)]
14379    pub nulls_first: Option<Box<Expression>>,
14380}
14381
14382/// SplitPart
14383#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14384#[cfg_attr(feature = "bindings", derive(TS))]
14385pub struct SplitPart {
14386    pub this: Box<Expression>,
14387    #[serde(default)]
14388    pub delimiter: Option<Box<Expression>>,
14389    #[serde(default)]
14390    pub part_index: Option<Box<Expression>>,
14391}
14392
14393/// SUBSTRING_INDEX(str, delim, count)
14394#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14395#[cfg_attr(feature = "bindings", derive(TS))]
14396pub struct SubstringIndex {
14397    pub this: Box<Expression>,
14398    #[serde(default)]
14399    pub delimiter: Option<Box<Expression>>,
14400    #[serde(default)]
14401    pub count: Option<Box<Expression>>,
14402}
14403
14404/// StandardHash
14405#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14406#[cfg_attr(feature = "bindings", derive(TS))]
14407pub struct StandardHash {
14408    pub this: Box<Expression>,
14409    #[serde(default)]
14410    pub expression: Option<Box<Expression>>,
14411}
14412
14413/// StrPosition
14414#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14415#[cfg_attr(feature = "bindings", derive(TS))]
14416pub struct StrPosition {
14417    pub this: Box<Expression>,
14418    #[serde(default)]
14419    pub substr: Option<Box<Expression>>,
14420    #[serde(default)]
14421    pub position: Option<Box<Expression>>,
14422    #[serde(default)]
14423    pub occurrence: Option<Box<Expression>>,
14424}
14425
14426/// Search
14427#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14428#[cfg_attr(feature = "bindings", derive(TS))]
14429pub struct Search {
14430    pub this: Box<Expression>,
14431    pub expression: Box<Expression>,
14432    #[serde(default)]
14433    pub json_scope: Option<Box<Expression>>,
14434    #[serde(default)]
14435    pub analyzer: Option<Box<Expression>>,
14436    #[serde(default)]
14437    pub analyzer_options: Option<Box<Expression>>,
14438    #[serde(default)]
14439    pub search_mode: Option<Box<Expression>>,
14440}
14441
14442/// SearchIp
14443#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14444#[cfg_attr(feature = "bindings", derive(TS))]
14445pub struct SearchIp {
14446    pub this: Box<Expression>,
14447    pub expression: Box<Expression>,
14448}
14449
14450/// StrToDate
14451#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14452#[cfg_attr(feature = "bindings", derive(TS))]
14453pub struct StrToDate {
14454    pub this: Box<Expression>,
14455    #[serde(default)]
14456    pub format: Option<String>,
14457    #[serde(default)]
14458    pub safe: Option<Box<Expression>>,
14459}
14460
14461/// StrToTime
14462#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14463#[cfg_attr(feature = "bindings", derive(TS))]
14464pub struct StrToTime {
14465    pub this: Box<Expression>,
14466    pub format: String,
14467    #[serde(default)]
14468    pub zone: Option<Box<Expression>>,
14469    #[serde(default)]
14470    pub safe: Option<Box<Expression>>,
14471    #[serde(default)]
14472    pub target_type: Option<Box<Expression>>,
14473}
14474
14475/// StrToUnix
14476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14477#[cfg_attr(feature = "bindings", derive(TS))]
14478pub struct StrToUnix {
14479    #[serde(default)]
14480    pub this: Option<Box<Expression>>,
14481    #[serde(default)]
14482    pub format: Option<String>,
14483}
14484
14485/// StrToMap
14486#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14487#[cfg_attr(feature = "bindings", derive(TS))]
14488pub struct StrToMap {
14489    pub this: Box<Expression>,
14490    #[serde(default)]
14491    pub pair_delim: Option<Box<Expression>>,
14492    #[serde(default)]
14493    pub key_value_delim: Option<Box<Expression>>,
14494    #[serde(default)]
14495    pub duplicate_resolution_callback: Option<Box<Expression>>,
14496}
14497
14498/// NumberToStr
14499#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14500#[cfg_attr(feature = "bindings", derive(TS))]
14501pub struct NumberToStr {
14502    pub this: Box<Expression>,
14503    pub format: String,
14504    #[serde(default)]
14505    pub culture: Option<Box<Expression>>,
14506}
14507
14508/// FromBase
14509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14510#[cfg_attr(feature = "bindings", derive(TS))]
14511pub struct FromBase {
14512    pub this: Box<Expression>,
14513    pub expression: Box<Expression>,
14514}
14515
14516/// Stuff
14517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14518#[cfg_attr(feature = "bindings", derive(TS))]
14519pub struct Stuff {
14520    pub this: Box<Expression>,
14521    #[serde(default)]
14522    pub start: Option<Box<Expression>>,
14523    #[serde(default)]
14524    pub length: Option<i64>,
14525    pub expression: Box<Expression>,
14526}
14527
14528/// TimeToStr
14529#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14530#[cfg_attr(feature = "bindings", derive(TS))]
14531pub struct TimeToStr {
14532    pub this: Box<Expression>,
14533    pub format: String,
14534    #[serde(default)]
14535    pub culture: Option<Box<Expression>>,
14536    #[serde(default)]
14537    pub zone: Option<Box<Expression>>,
14538}
14539
14540/// TimeStrToTime
14541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14542#[cfg_attr(feature = "bindings", derive(TS))]
14543pub struct TimeStrToTime {
14544    pub this: Box<Expression>,
14545    #[serde(default)]
14546    pub zone: Option<Box<Expression>>,
14547}
14548
14549/// TsOrDsAdd
14550#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14551#[cfg_attr(feature = "bindings", derive(TS))]
14552pub struct TsOrDsAdd {
14553    pub this: Box<Expression>,
14554    pub expression: Box<Expression>,
14555    #[serde(default)]
14556    pub unit: Option<String>,
14557    #[serde(default)]
14558    pub return_type: Option<Box<Expression>>,
14559}
14560
14561/// TsOrDsDiff
14562#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14563#[cfg_attr(feature = "bindings", derive(TS))]
14564pub struct TsOrDsDiff {
14565    pub this: Box<Expression>,
14566    pub expression: Box<Expression>,
14567    #[serde(default)]
14568    pub unit: Option<String>,
14569}
14570
14571/// TsOrDsToDate
14572#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14573#[cfg_attr(feature = "bindings", derive(TS))]
14574pub struct TsOrDsToDate {
14575    pub this: Box<Expression>,
14576    #[serde(default)]
14577    pub format: Option<String>,
14578    #[serde(default)]
14579    pub safe: Option<Box<Expression>>,
14580}
14581
14582/// TsOrDsToTime
14583#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14584#[cfg_attr(feature = "bindings", derive(TS))]
14585pub struct TsOrDsToTime {
14586    pub this: Box<Expression>,
14587    #[serde(default)]
14588    pub format: Option<String>,
14589    #[serde(default)]
14590    pub safe: Option<Box<Expression>>,
14591}
14592
14593/// Unhex
14594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14595#[cfg_attr(feature = "bindings", derive(TS))]
14596pub struct Unhex {
14597    pub this: Box<Expression>,
14598    #[serde(default)]
14599    pub expression: Option<Box<Expression>>,
14600}
14601
14602/// Uniform
14603#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14604#[cfg_attr(feature = "bindings", derive(TS))]
14605pub struct Uniform {
14606    pub this: Box<Expression>,
14607    pub expression: Box<Expression>,
14608    #[serde(default)]
14609    pub gen: Option<Box<Expression>>,
14610    #[serde(default)]
14611    pub seed: Option<Box<Expression>>,
14612}
14613
14614/// UnixToStr
14615#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14616#[cfg_attr(feature = "bindings", derive(TS))]
14617pub struct UnixToStr {
14618    pub this: Box<Expression>,
14619    #[serde(default)]
14620    pub format: Option<String>,
14621}
14622
14623/// UnixToTime
14624#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14625#[cfg_attr(feature = "bindings", derive(TS))]
14626pub struct UnixToTime {
14627    pub this: Box<Expression>,
14628    #[serde(default)]
14629    pub scale: Option<i64>,
14630    #[serde(default)]
14631    pub zone: Option<Box<Expression>>,
14632    #[serde(default)]
14633    pub hours: Option<Box<Expression>>,
14634    #[serde(default)]
14635    pub minutes: Option<Box<Expression>>,
14636    #[serde(default)]
14637    pub format: Option<String>,
14638    #[serde(default)]
14639    pub target_type: Option<Box<Expression>>,
14640}
14641
14642/// Uuid
14643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14644#[cfg_attr(feature = "bindings", derive(TS))]
14645pub struct Uuid {
14646    #[serde(default)]
14647    pub this: Option<Box<Expression>>,
14648    #[serde(default)]
14649    pub name: Option<String>,
14650    #[serde(default)]
14651    pub is_string: Option<Box<Expression>>,
14652}
14653
14654/// TimestampFromParts
14655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14656#[cfg_attr(feature = "bindings", derive(TS))]
14657pub struct TimestampFromParts {
14658    #[serde(default)]
14659    pub zone: Option<Box<Expression>>,
14660    #[serde(default)]
14661    pub milli: Option<Box<Expression>>,
14662    #[serde(default)]
14663    pub this: Option<Box<Expression>>,
14664    #[serde(default)]
14665    pub expression: Option<Box<Expression>>,
14666}
14667
14668/// TimestampTzFromParts
14669#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14670#[cfg_attr(feature = "bindings", derive(TS))]
14671pub struct TimestampTzFromParts {
14672    #[serde(default)]
14673    pub zone: Option<Box<Expression>>,
14674}
14675
14676/// Corr
14677#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14678#[cfg_attr(feature = "bindings", derive(TS))]
14679pub struct Corr {
14680    pub this: Box<Expression>,
14681    pub expression: Box<Expression>,
14682    #[serde(default)]
14683    pub null_on_zero_variance: Option<Box<Expression>>,
14684}
14685
14686/// WidthBucket
14687#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14688#[cfg_attr(feature = "bindings", derive(TS))]
14689pub struct WidthBucket {
14690    pub this: Box<Expression>,
14691    #[serde(default)]
14692    pub min_value: Option<Box<Expression>>,
14693    #[serde(default)]
14694    pub max_value: Option<Box<Expression>>,
14695    #[serde(default)]
14696    pub num_buckets: Option<Box<Expression>>,
14697    #[serde(default)]
14698    pub threshold: Option<Box<Expression>>,
14699}
14700
14701/// CovarSamp
14702#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14703#[cfg_attr(feature = "bindings", derive(TS))]
14704pub struct CovarSamp {
14705    pub this: Box<Expression>,
14706    pub expression: Box<Expression>,
14707}
14708
14709/// CovarPop
14710#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14711#[cfg_attr(feature = "bindings", derive(TS))]
14712pub struct CovarPop {
14713    pub this: Box<Expression>,
14714    pub expression: Box<Expression>,
14715}
14716
14717/// Week
14718#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14719#[cfg_attr(feature = "bindings", derive(TS))]
14720pub struct Week {
14721    pub this: Box<Expression>,
14722    #[serde(default)]
14723    pub mode: Option<Box<Expression>>,
14724}
14725
14726/// XMLElement
14727#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14728#[cfg_attr(feature = "bindings", derive(TS))]
14729pub struct XMLElement {
14730    pub this: Box<Expression>,
14731    #[serde(default)]
14732    pub expressions: Vec<Expression>,
14733    #[serde(default)]
14734    pub evalname: Option<Box<Expression>>,
14735}
14736
14737/// XMLGet
14738#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14739#[cfg_attr(feature = "bindings", derive(TS))]
14740pub struct XMLGet {
14741    pub this: Box<Expression>,
14742    pub expression: Box<Expression>,
14743    #[serde(default)]
14744    pub instance: Option<Box<Expression>>,
14745}
14746
14747/// XMLTable
14748#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14749#[cfg_attr(feature = "bindings", derive(TS))]
14750pub struct XMLTable {
14751    pub this: Box<Expression>,
14752    #[serde(default)]
14753    pub namespaces: Option<Box<Expression>>,
14754    #[serde(default)]
14755    pub passing: Option<Box<Expression>>,
14756    #[serde(default)]
14757    pub columns: Vec<Expression>,
14758    #[serde(default)]
14759    pub by_ref: Option<Box<Expression>>,
14760}
14761
14762/// XMLKeyValueOption
14763#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14764#[cfg_attr(feature = "bindings", derive(TS))]
14765pub struct XMLKeyValueOption {
14766    pub this: Box<Expression>,
14767    #[serde(default)]
14768    pub expression: Option<Box<Expression>>,
14769}
14770
14771/// Zipf
14772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14773#[cfg_attr(feature = "bindings", derive(TS))]
14774pub struct Zipf {
14775    pub this: Box<Expression>,
14776    #[serde(default)]
14777    pub elementcount: Option<Box<Expression>>,
14778    #[serde(default)]
14779    pub gen: Option<Box<Expression>>,
14780}
14781
14782/// Merge
14783#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14784#[cfg_attr(feature = "bindings", derive(TS))]
14785pub struct Merge {
14786    pub this: Box<Expression>,
14787    pub using: Box<Expression>,
14788    #[serde(default)]
14789    pub on: Option<Box<Expression>>,
14790    #[serde(default)]
14791    pub using_cond: Option<Box<Expression>>,
14792    #[serde(default)]
14793    pub whens: Option<Box<Expression>>,
14794    #[serde(default)]
14795    pub with_: Option<Box<Expression>>,
14796    #[serde(default)]
14797    pub returning: Option<Box<Expression>>,
14798}
14799
14800/// When
14801#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14802#[cfg_attr(feature = "bindings", derive(TS))]
14803pub struct When {
14804    #[serde(default)]
14805    pub matched: Option<Box<Expression>>,
14806    #[serde(default)]
14807    pub source: Option<Box<Expression>>,
14808    #[serde(default)]
14809    pub condition: Option<Box<Expression>>,
14810    pub then: Box<Expression>,
14811}
14812
14813/// Wraps around one or more WHEN [NOT] MATCHED [...] clauses.
14814#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14815#[cfg_attr(feature = "bindings", derive(TS))]
14816pub struct Whens {
14817    #[serde(default)]
14818    pub expressions: Vec<Expression>,
14819}
14820
14821/// NextValueFor
14822#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
14823#[cfg_attr(feature = "bindings", derive(TS))]
14824pub struct NextValueFor {
14825    pub this: Box<Expression>,
14826    #[serde(default)]
14827    pub order: Option<Box<Expression>>,
14828}
14829
14830#[cfg(test)]
14831mod tests {
14832    use super::*;
14833
14834    #[test]
14835    #[cfg(feature = "bindings")]
14836    fn export_typescript_types() {
14837        // This test exports TypeScript types to the generated directory
14838        // Run with: cargo test -p polyglot-sql --features bindings export_typescript_types
14839        Expression::export_all(&ts_rs::Config::default())
14840            .expect("Failed to export Expression types");
14841    }
14842
14843    #[test]
14844    fn test_simple_select_builder() {
14845        let select = Select::new()
14846            .column(Expression::star())
14847            .from(Expression::Table(Box::new(TableRef::new("users"))));
14848
14849        assert_eq!(select.expressions.len(), 1);
14850        assert!(select.from.is_some());
14851    }
14852
14853    #[test]
14854    fn test_expression_alias() {
14855        let expr = Expression::column("id").alias("user_id");
14856
14857        match expr {
14858            Expression::Alias(a) => {
14859                assert_eq!(a.alias.name, "user_id");
14860            }
14861            _ => panic!("Expected Alias"),
14862        }
14863    }
14864
14865    #[test]
14866    fn test_literal_creation() {
14867        let num = Expression::number(42);
14868        let str = Expression::string("hello");
14869
14870        match num {
14871            Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Number(_)) => {
14872                let Literal::Number(n) = lit.as_ref() else {
14873                    unreachable!()
14874                };
14875                assert_eq!(n, "42")
14876            }
14877            _ => panic!("Expected Number"),
14878        }
14879
14880        match str {
14881            Expression::Literal(lit) if matches!(lit.as_ref(), Literal::String(_)) => {
14882                let Literal::String(s) = lit.as_ref() else {
14883                    unreachable!()
14884                };
14885                assert_eq!(s, "hello")
14886            }
14887            _ => panic!("Expected String"),
14888        }
14889    }
14890
14891    #[test]
14892    fn test_expression_sql() {
14893        let expr = crate::parse_one("SELECT 1 + 2", crate::DialectType::Generic).unwrap();
14894        assert_eq!(expr.sql(), "SELECT 1 + 2");
14895    }
14896
14897    #[test]
14898    fn test_expression_sql_for() {
14899        let expr = crate::parse_one("SELECT IF(x > 0, 1, 0)", crate::DialectType::Generic).unwrap();
14900        let sql = expr.sql_for(crate::DialectType::Generic);
14901        // Generic mode normalizes IF() to CASE WHEN
14902        assert!(sql.contains("CASE WHEN"), "Expected CASE WHEN in: {}", sql);
14903    }
14904}
polyglot_sql/expressions.rs

polyglot_sql/
expressions.rs
