inbq/
ast.rs

1use serde::{Deserialize, Serialize};
2use strum_macros::{Display, EnumDiscriminants};
3
4#[derive(Debug, Clone, Serialize, Deserialize)]
5pub struct Ast {
6    pub statements: Vec<Statement>,
7}
8
9#[derive(Debug, Clone, Serialize, Deserialize)]
10pub enum Statement {
11    Query(QueryStatement),
12    Insert(InsertStatement),
13    Delete(DeleteStatement),
14    Update(Box<UpdateStatement>),
15    Truncate(TruncateStatement),
16    Merge(Box<MergeStatement>),
17    DeclareVar(DeclareVarStatement),
18    SetVar(SetVarStatement),
19    Block(StatementsBlock),
20    CreateSchema(CreateSchemaStatement),
21    CreateTable(Box<CreateTableStatement>),
22    CreateSqlFunction(CreateSqlFunctionStatement),
23    CreateJsFunction(CreateJsFunctionStatement),
24    CreateView(CreateViewStatement),
25    DropTable(DropTableStatement),
26    DropView(DropViewStatement),
27    UndropSchema(UndropSchemaStatement),
28    DropSchema(DropSchemaStatement),
29    DropFunction(DropFunctionStatement),
30    If(IfStatement),
31    Case(CaseStatement),
32    BeginTransaction,
33    CommitTransaction,
34    RollbackTransaction,
35    Raise(RaiseStatement),
36    Return,
37    Call(CallStatement),
38    ExecuteImmediate(ExecuteImmediateStatement),
39    Loop(LoopStatement),
40    Repeat(RepeatStatement),
41    While(WhileStatement),
42    ForIn(ForInStatement),
43    Break,
44    Continue,
45    Iterate,
46    Leave,
47    Labeled(LabeledStatement),
48}
49
50#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct DropViewStatement {
52    pub name: PathName,
53    pub if_exists: bool,
54}
55
56#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
57pub enum DropSchemaMode {
58    Restrict,
59    Cascade,
60}
61
62#[derive(Debug, Clone, Serialize, Deserialize)]
63pub struct DropSchemaStatement {
64    pub name: PathName,
65    pub external: bool,
66    pub if_exists: bool,
67    pub mode: Option<DropSchemaMode>,
68}
69
70#[derive(Debug, Clone, Serialize, Deserialize)]
71pub struct UndropSchemaStatement {
72    pub name: PathName,
73    pub if_not_exists: bool,
74    pub options: Option<Vec<DdlOption>>,
75}
76
77#[derive(Debug, Clone, Serialize, Deserialize)]
78pub struct DropFunctionStatement {
79    pub name: PathName,
80    pub if_exists: bool,
81}
82
83#[derive(Debug, Clone, Serialize, Deserialize)]
84pub enum FunctionArgumentType {
85    Standard(Type),
86    AnyType,
87}
88
89#[derive(Debug, Clone, Serialize, Deserialize)]
90pub struct FunctionArgument {
91    pub name: Name,
92    pub r#type: FunctionArgumentType,
93}
94
95#[derive(Debug, Clone, Serialize, Deserialize)]
96pub struct CreateSqlFunctionStatement {
97    pub name: PathName,
98    pub replace: bool,
99    pub is_temporary: bool,
100    pub if_not_exists: bool,
101    pub arguments: Vec<FunctionArgument>,
102    pub returns: Option<Type>,
103    pub options: Option<Vec<DdlOption>>,
104    pub body: Expr,
105}
106
107#[derive(Debug, Clone, Serialize, Deserialize)]
108pub struct CreateJsFunctionStatement {
109    pub name: PathName,
110    pub replace: bool,
111    pub is_temporary: bool,
112    pub if_not_exists: bool,
113    pub arguments: Vec<FunctionArgument>,
114    pub returns: Type,
115    pub is_deterministic: Option<bool>,
116    pub options: Option<Vec<DdlOption>>,
117    pub body: Expr,
118}
119
120#[derive(Debug, Clone, Serialize, Deserialize)]
121pub struct CreateSchemaStatement {
122    pub name: PathName,
123    pub if_not_exists: bool,
124    pub default_collate: Option<Expr>,
125    pub options: Option<Vec<DdlOption>>,
126}
127
128#[derive(Debug, Clone, Serialize, Deserialize)]
129pub struct ExecuteImmediateStatement {
130    pub sql: Expr,
131    pub into_vars: Option<Vec<Name>>,
132    pub using_identifiers: Option<Vec<ExecuteImmediateUsingIdentifier>>,
133}
134
135#[derive(Debug, Clone, Serialize, Deserialize)]
136pub struct ExecuteImmediateUsingIdentifier {
137    pub identifier: Expr,
138    pub alias: Option<Name>,
139}
140
141#[derive(Debug, Clone, Serialize, Deserialize)]
142pub struct CreateViewStatement {
143    pub replace: bool,
144    pub if_not_exists: bool,
145    pub name: PathName,
146    pub columns: Option<Vec<ViewColumn>>,
147    pub options: Option<Vec<DdlOption>>,
148    pub query: QueryExpr,
149}
150
151#[derive(Debug, Clone, Serialize, Deserialize)]
152pub struct ViewColumn {
153    pub name: Name,
154    pub options: Option<Vec<DdlOption>>,
155}
156
157#[derive(Debug, Clone, Serialize, Deserialize)]
158pub struct DdlOption {
159    pub name: Name,
160    pub value: Expr,
161}
162
163#[derive(Debug, Clone, Serialize, Deserialize)]
164pub struct ForInStatement {
165    pub var_name: Name,
166    pub table_expr: QueryExpr,
167    pub statements: Vec<Statement>,
168}
169
170#[derive(Debug, Clone, Serialize, Deserialize)]
171pub struct WhileStatement {
172    pub condition: Expr,
173    pub statements: Vec<Statement>,
174}
175
176#[derive(Debug, Clone, Serialize, Deserialize)]
177pub struct RepeatStatement {
178    pub statements: Vec<Statement>,
179    pub until: Expr,
180}
181
182#[derive(Debug, Clone, Serialize, Deserialize)]
183pub struct LoopStatement {
184    pub statements: Vec<Statement>,
185}
186
187#[derive(Debug, Clone, Serialize, Deserialize)]
188pub struct LabeledStatement {
189    pub statement: Box<Statement>,
190    pub start_label: Name,
191    pub end_label: Option<Name>,
192}
193
194#[derive(Debug, Clone, Serialize, Deserialize)]
195pub enum Name {
196    Identifier(Identifier),
197    QuotedIdentifier(QuotedIdentifier),
198}
199
200impl Name {
201    pub fn as_str(&self) -> &str {
202        match self {
203            Name::Identifier(identifier) => &identifier.name,
204            Name::QuotedIdentifier(quoted_identifier) => &quoted_identifier.name,
205        }
206    }
207}
208
209#[derive(Debug, Clone, Serialize, Deserialize)]
210pub struct PathName {
211    pub name: String,
212    pub parts: Vec<PathPart>,
213}
214
215impl std::convert::From<Vec<PathPart>> for PathName {
216    fn from(value: Vec<PathPart>) -> Self {
217        let name = value
218            .iter()
219            .map(|p| match p {
220                PathPart::Identifier(identifier) => &identifier.name,
221                PathPart::QuotedIdentifier(quoted_identifier) => &quoted_identifier.name,
222                PathPart::Number(number) => &number.value,
223                PathPart::DotSeparator => ".",
224                PathPart::SlashSeparator => "/",
225                PathPart::DashSeparator => "-",
226                PathPart::ColonSeparator => ":",
227            })
228            .collect::<Vec<&str>>()
229            .join("");
230        Self { name, parts: value }
231    }
232}
233
234impl PathName {
235    pub fn identifiers(&self) -> Vec<&str> {
236        self.parts
237            .iter()
238            .filter_map(|p| match p {
239                PathPart::Identifier(identifier) => Some(identifier.name.as_str()),
240                PathPart::QuotedIdentifier(quoted_identifier) => {
241                    Some(quoted_identifier.name.as_str())
242                }
243                _ => None,
244            })
245            .collect()
246    }
247}
248
249#[derive(Debug, Clone, Serialize, Deserialize)]
250pub enum PathPart {
251    Identifier(Identifier),
252    QuotedIdentifier(QuotedIdentifier),
253    Number(Number),
254    DotSeparator,
255    SlashSeparator,
256    DashSeparator,
257    ColonSeparator,
258}
259
260#[derive(Debug, Clone, Serialize, Deserialize)]
261pub struct CaseStatement {
262    pub case: Option<Expr>,
263    pub when_thens: Vec<CaseWhenThenStatements>,
264    pub r#else: Option<Vec<Statement>>,
265}
266
267#[derive(Debug, Clone, Serialize, Deserialize)]
268pub struct CaseWhenThenStatements {
269    pub when: Expr,
270    pub then: Vec<Statement>,
271}
272
273#[derive(Debug, Clone, Serialize, Deserialize)]
274pub struct CallStatement {
275    pub procedure_name: PathName,
276    pub arguments: Vec<Expr>,
277}
278
279#[derive(Debug, Clone, Serialize, Deserialize)]
280pub struct RaiseStatement {
281    pub message: Option<Expr>,
282}
283
284#[derive(Debug, Clone, Serialize, Deserialize)]
285pub struct IfStatement {
286    pub r#if: IfBranch,
287    pub else_ifs: Option<Vec<IfBranch>>,
288    pub r#else: Option<Vec<Statement>>,
289}
290
291#[derive(Debug, Clone, Serialize, Deserialize)]
292pub struct IfBranch {
293    pub condition: Expr,
294    pub statements: Vec<Statement>,
295}
296
297#[derive(Debug, Clone, Serialize, Deserialize)]
298pub struct StatementsBlock {
299    pub statements: Vec<Statement>,
300    pub exception_statements: Option<Vec<Statement>>,
301}
302
303#[derive(Debug, Clone, Serialize, Deserialize)]
304pub struct DeclareVarStatement {
305    pub vars: Vec<Name>,
306    pub r#type: Option<ParameterizedType>,
307    pub default: Option<Expr>,
308}
309
310#[derive(Debug, Clone, Serialize, Deserialize)]
311pub struct SetVarStatement {
312    pub vars: Vec<SetVariable>,
313    pub exprs: Vec<Expr>,
314}
315
316#[derive(Debug, Clone, Serialize, Deserialize)]
317pub enum SetVariable {
318    UserVariable(Name),
319    SystemVariable(SystemVariable),
320}
321
322#[derive(Debug, Clone, Serialize, Deserialize)]
323pub struct CreateTableStatement {
324    pub name: PathName,
325    pub schema: Option<Vec<ColumnSchema>>,
326    pub constraints: Option<Vec<TableConstraint>>,
327    pub default_collate: Option<Expr>,
328    pub partition: Option<Expr>,
329    pub clustering_columns: Option<Vec<Name>>,
330    pub connection: Option<PathName>,
331    pub options: Option<Vec<DdlOption>>,
332    pub replace: bool,
333    pub is_temporary: bool,
334    pub if_not_exists: bool,
335    pub query: Option<QueryExpr>,
336}
337
338#[derive(Debug, Clone, Serialize, Deserialize)]
339pub enum TableConstraint {
340    PrimaryKeyNotEnforced(PrimaryKeyConstraintNotEnforced),
341    ForeignKeyNotEnforced(ForeignKeyConstraintNotEnforced),
342}
343
344#[derive(Debug, Clone, Serialize, Deserialize)]
345pub struct PrimaryKeyConstraintNotEnforced {
346    pub columns: Vec<Name>,
347}
348
349#[derive(Debug, Clone, Serialize, Deserialize)]
350pub struct ForeignKeyConstraintNotEnforced {
351    pub name: Option<Name>,
352    pub columns: Vec<Name>,
353    pub reference: ForeignKeyReference,
354}
355
356#[derive(Debug, Clone, Serialize, Deserialize)]
357pub struct ForeignKeyReference {
358    pub table: PathName,
359    pub columns: Vec<Name>,
360}
361
362#[derive(Debug, Clone, Serialize, Deserialize)]
363pub struct DropTableStatement {
364    pub name: PathName,
365    pub if_exists: bool,
366}
367
368#[derive(Debug, Clone, Serialize, Deserialize)]
369pub struct ColumnSchema {
370    pub name: Name,
371    pub r#type: ParameterizedType,
372}
373
374#[derive(Debug, Clone, Serialize, Deserialize)]
375pub enum ParameterizedType {
376    Array {
377        r#type: Box<ParameterizedType>,
378    },
379    BigNumeric {
380        precision: Option<String>,
381        scale: Option<String>,
382    },
383    Bool,
384    Bytes {
385        max_length: Option<String>,
386    },
387    Date,
388    Datetime,
389    Float64,
390    Geography,
391    Int64,
392    Interval,
393    Json,
394    Numeric {
395        precision: Option<String>,
396        scale: Option<String>,
397    },
398    Range {
399        r#type: Box<ParameterizedType>,
400    },
401    String {
402        max_length: Option<String>,
403    },
404    Struct {
405        fields: Vec<StructParameterizedFieldType>,
406    },
407    Time,
408    Timestamp,
409}
410
411#[derive(Debug, Clone, Serialize, Deserialize)]
412pub struct StructParameterizedFieldType {
413    pub name: Name,
414    pub r#type: ParameterizedType,
415}
416
417#[derive(Debug, Clone, Serialize, Deserialize)]
418pub enum Type {
419    Array { r#type: Box<Type> },
420    BigNumeric,
421    Bool,
422    Bytes,
423    Date,
424    Datetime,
425    Float64,
426    Geography,
427    Int64,
428    Interval,
429    Json,
430    Numeric,
431    Range { r#type: Box<Type> },
432    String,
433    Struct { fields: Vec<StructFieldType> },
434    Time,
435    Timestamp,
436}
437
438#[derive(Debug, Clone, Serialize, Deserialize)]
439pub struct StructFieldType {
440    pub name: Option<Name>,
441    pub r#type: Type,
442}
443
444#[derive(Debug, Clone, Serialize, Deserialize)]
445pub struct QueryStatement {
446    pub query: QueryExpr,
447}
448
449#[derive(Debug, Clone, Serialize, Deserialize)]
450pub struct InsertStatement {
451    pub table: PathName,
452    pub columns: Option<Vec<Name>>,
453    pub values: Option<Vec<Expr>>,
454    pub query: Option<QueryExpr>,
455}
456
457#[derive(Debug, Clone, Serialize, Deserialize)]
458pub struct DeleteStatement {
459    pub table: PathName,
460    pub alias: Option<Name>,
461    pub cond: Expr,
462}
463
464#[derive(Debug, Clone, Serialize, Deserialize)]
465pub struct UpdateItem {
466    pub column: Expr,
467    pub expr: Expr,
468}
469
470#[derive(Debug, Clone, Serialize, Deserialize)]
471pub struct UpdateStatement {
472    pub table: PathName,
473    pub alias: Option<Name>,
474    pub update_items: Vec<UpdateItem>,
475    pub from: Option<From>,
476    pub r#where: Where,
477}
478
479#[derive(Debug, Clone, Serialize, Deserialize)]
480pub struct TruncateStatement {
481    pub table: PathName,
482}
483
484#[derive(Debug, Clone, Serialize, Deserialize)]
485pub struct MergeStatement {
486    pub target_table: PathName,
487    pub target_alias: Option<Name>,
488    pub source: MergeSource,
489    pub source_alias: Option<Name>,
490    pub condition: Expr,
491    pub whens: Vec<When>,
492}
493
494#[derive(Debug, Clone, Serialize, Deserialize)]
495pub enum MergeSource {
496    Table(PathName),
497    Subquery(QueryExpr),
498}
499
500#[derive(Debug, Clone, Serialize, Deserialize)]
501pub enum Merge {
502    Update(MergeUpdate),
503    Insert(MergeInsert),
504    InsertRow,
505    Delete,
506}
507
508#[derive(Debug, Clone, Serialize, Deserialize)]
509pub struct MergeUpdate {
510    pub update_items: Vec<UpdateItem>,
511}
512
513#[derive(Debug, Clone, Serialize, Deserialize)]
514pub struct MergeInsert {
515    pub columns: Option<Vec<Name>>,
516    pub values: Vec<Expr>,
517}
518
519#[derive(Debug, Clone, Serialize, Deserialize)]
520pub enum When {
521    Matched(WhenMatched),
522    NotMatchedByTarget(WhenNotMatchedByTarget),
523    NotMatchedBySource(WhenNotMatchedBySource),
524}
525
526#[derive(Debug, Clone, Serialize, Deserialize)]
527pub struct WhenMatched {
528    pub search_condition: Option<Expr>,
529    pub merge: Merge,
530}
531
532#[derive(Debug, Clone, Serialize, Deserialize)]
533pub struct WhenNotMatchedByTarget {
534    pub search_condition: Option<Expr>,
535    pub merge: Merge,
536}
537
538#[derive(Debug, Clone, Serialize, Deserialize)]
539pub struct WhenNotMatchedBySource {
540    pub search_condition: Option<Expr>,
541    pub merge: Merge,
542}
543
544#[derive(Debug, Clone, Serialize, Deserialize)]
545pub enum Expr {
546    Binary(BinaryExpr),
547    Unary(UnaryExpr),
548    Grouping(GroupingExpr),
549    Array(ArrayExpr),
550    Struct(StructExpr),
551    Identifier(Identifier),
552    QuotedIdentifier(QuotedIdentifier),
553    QueryNamedParameter(String),
554    QueryPositionalParameter,
555    SystemVariable(SystemVariable),
556    String(String),
557    RawString(String),
558    StringConcat(StringConcatExpr),
559    Bytes(String),
560    RawBytes(String),
561    BytesConcat(BytesConcatExpr),
562    Numeric(String),
563    BigNumeric(String),
564    Number(Number),
565    Bool(bool),
566    With(WithExpr),
567    Date(String),
568    Time(String),
569    Datetime(String),
570    Timestamp(String),
571    Range(RangeExpr),
572    Interval(IntervalExpr),
573    Json(String),
574    Default,
575    Null,
576    Star,
577    Query(Box<QueryExpr>),
578    Case(CaseExpr),
579    GenericFunction(Box<GenericFunctionExpr>),
580    Function(Box<FunctionExpr>),
581    QuantifiedLike(QuantifiedLikeExpr),
582    Exists(Box<QueryExpr>),
583    Unnest(UnnestExpr),
584}
585
586#[derive(Debug, Clone, Serialize, Deserialize)]
587pub struct UnnestExpr {
588    pub array: Box<Expr>,
589}
590
591#[derive(Debug, Clone, Serialize, Deserialize)]
592pub struct WithExpr {
593    pub vars: Vec<WithExprVar>,
594    pub result: Box<Expr>,
595}
596
597#[derive(Debug, Clone, Serialize, Deserialize)]
598pub struct WithExprVar {
599    pub name: Name,
600    pub value: Expr,
601}
602
603#[derive(Debug, Clone, Serialize, Deserialize)]
604pub struct SystemVariable {
605    pub name: String,
606}
607
608#[derive(Debug, Clone, Serialize, Deserialize)]
609pub struct Number {
610    pub value: String,
611}
612
613#[derive(Debug, Clone, Serialize, Deserialize)]
614pub struct Identifier {
615    pub name: String,
616}
617
618#[derive(Debug, Clone, Serialize, Deserialize)]
619pub struct QuotedIdentifier {
620    pub name: String,
621}
622
623#[derive(Debug, Clone, Serialize, Deserialize)]
624pub struct StringConcatExpr {
625    pub strings: Vec<Expr>,
626}
627
628#[derive(Debug, Clone, Serialize, Deserialize)]
629pub struct BytesConcatExpr {
630    pub bytes: Vec<Expr>,
631}
632
633#[derive(Debug, Clone, Serialize, Deserialize)]
634pub struct CaseExpr {
635    pub case: Option<Box<Expr>>,
636    pub when_thens: Vec<WhenThen>,
637    pub r#else: Option<Box<Expr>>,
638}
639
640#[derive(Debug, Clone, Serialize, Deserialize)]
641pub struct WhenThen {
642    pub when: Expr,
643    pub then: Expr,
644}
645
646#[derive(Debug, Clone, Serialize, Deserialize)]
647pub struct RangeExpr {
648    pub r#type: Type,
649    pub value: String,
650}
651
652#[derive(Debug, Clone, Serialize, Deserialize)]
653pub enum IntervalExpr {
654    Interval {
655        value: Box<Expr>,
656        part: IntervalPart,
657    },
658    IntervalRange {
659        value: String,
660        start_part: IntervalPart,
661        end_part: IntervalPart,
662    },
663}
664
665#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
666pub enum IntervalPart {
667    Year,
668    Quarter,
669    Month,
670    Week,
671    Day,
672    Hour,
673    Minute,
674    Second,
675    Millisecond,
676    Microsecond,
677}
678
679#[derive(Debug, Clone, Serialize, Deserialize)]
680pub enum FunctionExpr {
681    // list of known functions here
682    // https://cloud.google.com/bigquery/docs/reference/standard-sql/functions-all
683    Array(ArrayFunctionExpr),
684    ArrayAgg(ArrayAggFunctionExpr),
685    Coalesce(CoalesceFunctionExpr),
686    Concat(ConcatFunctionExpr),
687    Cast(CastFunctionExpr),
688    SafeCast(SafeCastFunctionExpr),
689    Extract(ExtractFunctionExpr),
690    If(IfFunctionExpr),
691
692    /// Date
693    CurrentDate(CurrentDateFunctionExpr),
694    DateDiff(DateDiffFunctionExpr),
695    DateTrunc(DateTruncFunctionExpr),
696
697    /// Datetime
698    CurrentDatetime(CurrentDatetimeFunctionExpr),
699    DatetimeDiff(DatetimeDiffFunctionExpr),
700    DatetimeTrunc(DatetimeTruncFunctionExpr),
701
702    /// Timestamp
703    CurrentTimestamp,
704    TimestampDiff(TimestampDiffFunctionExpr),
705    TimestampTrunc(TimestampTruncFunctionExpr),
706
707    /// Time
708    CurrentTime(CurrentTimeFunctionExpr),
709    TimeDiff(TimeDiffFunctionExpr),
710    TimeTrunc(TimeTruncFunctionExpr),
711
712    LastDay(LastDayFunctionExpr),
713
714    Left(LeftFunctionExpr),
715    Right(RightFunctionExpr),
716
717    // String
718    Normalize(NormalizeFunctionExpr),
719    NormalizeAndCasefold(NormalizeAndCasefoldFunctionExpr),
720}
721
722#[derive(Debug, Clone, Serialize, Deserialize)]
723pub struct CoalesceFunctionExpr {
724    pub exprs: Vec<Expr>,
725}
726
727#[derive(Debug, Clone, Serialize, Deserialize)]
728pub struct NormalizeFunctionExpr {
729    pub value: Expr,
730    pub mode: NormalizationMode,
731}
732
733#[derive(Debug, Clone, Serialize, Deserialize)]
734pub struct NormalizeAndCasefoldFunctionExpr {
735    pub value: Expr,
736    pub mode: NormalizationMode,
737}
738
739#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
740pub enum NormalizationMode {
741    NFC,
742    NFKC,
743    NFD,
744    NFKD,
745}
746
747#[derive(Debug, Clone, Serialize, Deserialize)]
748pub struct CurrentDatetimeFunctionExpr {
749    pub timezone: Option<Expr>,
750}
751
752#[derive(Debug, Clone, Serialize, Deserialize)]
753pub struct CurrentTimeFunctionExpr {
754    pub timezone: Option<Expr>,
755}
756
757#[derive(Debug, Clone, Serialize, Deserialize)]
758pub struct LastDayFunctionExpr {
759    pub expr: Expr,
760    pub granularity: Option<Granularity>,
761}
762
763#[derive(Debug, Clone, Serialize, Deserialize)]
764pub struct DateTruncFunctionExpr {
765    pub date: Expr,
766    pub granularity: Granularity,
767}
768
769#[derive(Debug, Clone, Serialize, Deserialize)]
770pub struct DateDiffFunctionExpr {
771    pub start_date: Expr,
772    pub end_date: Expr,
773    pub granularity: Granularity,
774}
775
776#[derive(Debug, Clone, Serialize, Deserialize)]
777pub struct DatetimeTruncFunctionExpr {
778    pub datetime: Expr,
779    pub granularity: Granularity,
780    pub timezone: Option<Expr>,
781}
782
783#[derive(Debug, Clone, Serialize, Deserialize)]
784pub struct DatetimeDiffFunctionExpr {
785    pub start_datetime: Expr,
786    pub end_datetime: Expr,
787    pub granularity: Granularity,
788}
789
790#[derive(Debug, Clone, Serialize, Deserialize)]
791pub struct TimestampTruncFunctionExpr {
792    pub timestamp: Expr,
793    pub granularity: Granularity,
794    pub timezone: Option<Expr>,
795}
796
797#[derive(Debug, Clone, Serialize, Deserialize)]
798pub struct TimestampDiffFunctionExpr {
799    pub start_timestamp: Expr,
800    pub end_timestamp: Expr,
801    pub granularity: Granularity,
802}
803
804#[derive(Debug, Clone, Serialize, Deserialize)]
805pub struct TimeTruncFunctionExpr {
806    pub time: Expr,
807    pub granularity: Granularity,
808}
809
810#[derive(Debug, Clone, Serialize, Deserialize)]
811pub struct TimeDiffFunctionExpr {
812    pub start_time: Expr,
813    pub end_time: Expr,
814    pub granularity: Granularity,
815}
816
817#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
818pub enum Granularity {
819    MicroSecond,
820    MilliSecond,
821    Second,
822    Minute,
823    Hour,
824    Day,
825    Week,
826    WeekWithBegin(WeekBegin),
827    IsoWeek,
828    Month,
829    Quarter,
830    Year,
831    IsoYear,
832    Date,
833    Time,
834}
835
836#[derive(Debug, Clone, Serialize, Deserialize)]
837pub struct RightFunctionExpr {
838    pub value: Expr,
839    pub length: Expr,
840}
841
842#[derive(Debug, Clone, Serialize, Deserialize)]
843pub struct LeftFunctionExpr {
844    pub value: Expr,
845    pub length: Expr,
846}
847
848#[derive(Debug, Clone, Serialize, Deserialize)]
849pub struct ExtractFunctionExpr {
850    pub part: ExtractFunctionPart,
851    pub expr: Box<Expr>,
852}
853
854#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
855pub enum ExtractFunctionPart {
856    MicroSecond,
857    MilliSecond,
858    Second,
859    Minute,
860    Hour,
861    DayOfWeek,
862    Day,
863    DayOfYear,
864    Week,
865    WeekWithBegin(WeekBegin),
866    IsoWeek,
867    Month,
868    Quarter,
869    Year,
870    IsoYear,
871    Date,
872    Time,
873}
874
875#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
876pub enum WeekBegin {
877    Sunday,
878    Monday,
879    Tuesday,
880    Wednesday,
881    Thursday,
882    Friday,
883    Saturday,
884}
885
886#[derive(Debug, Clone, Serialize, Deserialize)]
887pub struct CurrentDateFunctionExpr {
888    pub timezone: Option<Expr>,
889}
890
891#[derive(Debug, Clone, Serialize, Deserialize)]
892pub struct ArrayAggFunctionExpr {
893    pub arg: Box<GenericFunctionExprArg>,
894    pub over: Option<NamedWindowExpr>,
895}
896
897#[derive(Debug, Clone, Serialize, Deserialize)]
898pub struct ArrayFunctionExpr {
899    pub query: QueryExpr,
900}
901
902#[derive(Debug, Clone, Serialize, Deserialize)]
903pub struct ConcatFunctionExpr {
904    pub values: Vec<Expr>,
905}
906
907#[derive(Debug, Clone, Serialize, Deserialize)]
908pub struct CastFunctionExpr {
909    pub expr: Box<Expr>,
910    pub r#type: ParameterizedType,
911    pub format: Option<CastFunctionFormat>,
912}
913
914#[derive(Debug, Clone, Serialize, Deserialize)]
915pub struct SafeCastFunctionExpr {
916    pub expr: Box<Expr>,
917    pub r#type: ParameterizedType,
918    pub format: Option<CastFunctionFormat>,
919}
920
921#[derive(Debug, Clone, Serialize, Deserialize)]
922pub struct CastFunctionFormat {
923    pub format: Expr,
924    pub time_zone: Option<Expr>,
925}
926
927#[derive(Debug, Clone, Serialize, Deserialize)]
928pub struct IfFunctionExpr {
929    pub condition: Box<Expr>,
930    pub true_result: Box<Expr>,
931    pub false_result: Box<Expr>,
932}
933
934/// Generic function call, whose signature is not yet implemented in the parser
935#[derive(Debug, Clone, Serialize, Deserialize)]
936pub struct GenericFunctionExpr {
937    pub name: Name,
938    pub arguments: Vec<GenericFunctionExprArg>,
939    pub over: Option<NamedWindowExpr>,
940}
941
942#[derive(Debug, Clone, Serialize, Deserialize)]
943pub struct GenericFunctionExprArg {
944    pub name: Option<Name>,
945    pub expr: Expr,
946    pub aggregate: Option<FunctionAggregate>,
947}
948
949#[derive(Debug, Clone, Serialize, Deserialize)]
950pub struct FunctionAggregate {
951    pub distinct: bool,
952    pub nulls: Option<FunctionAggregateNulls>,
953    pub having: Option<FunctionAggregateHaving>,
954    pub order_by: Option<Vec<FunctionAggregateOrderBy>>,
955    pub limit: Option<Box<Expr>>,
956}
957
958#[derive(Debug, Clone, Serialize, Deserialize)]
959pub struct FunctionAggregateOrderBy {
960    pub expr: Box<Expr>,
961    pub sort_direction: Option<OrderBySortDirection>,
962    pub nulls: Option<OrderByNulls>,
963}
964
965#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
966pub enum FunctionAggregateNulls {
967    Ignore,
968    Respect,
969}
970
971#[derive(Debug, Clone, Serialize, Deserialize)]
972pub struct FunctionAggregateHaving {
973    pub expr: Box<Expr>,
974    pub kind: FunctionAggregateHavingKind,
975}
976
977#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
978pub enum FunctionAggregateHavingKind {
979    Max,
980    Min,
981}
982
983#[derive(Debug, Clone, Serialize, Deserialize)]
984pub struct UnaryExpr {
985    pub operator: UnaryOperator,
986    pub right: Box<Expr>,
987}
988
989#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
990pub enum UnaryOperator {
991    Plus,
992    Minus,
993    BitwiseNot,
994    IsNull,
995    IsNotNull,
996    IsTrue,
997    IsNotTrue,
998    IsFalse,
999    IsNotFalse,
1000    Not,
1001}
1002
1003#[derive(Debug, Clone, Serialize, Deserialize)]
1004pub struct BinaryExpr {
1005    pub left: Box<Expr>,
1006    pub operator: BinaryOperator,
1007    pub right: Box<Expr>,
1008}
1009
1010#[derive(Debug, Clone, Copy, Serialize, Deserialize, Display, PartialEq, Eq)]
1011pub enum BinaryOperator {
1012    Star,
1013    Slash,
1014    Concat,
1015    Plus,
1016    Minus,
1017    BitwiseLeftShift,
1018    BitwiseRightShift,
1019    BitwiseAnd,
1020    BitwiseXor,
1021    BitwiseOr,
1022    Equal,
1023    LessThan,
1024    GreaterThan,
1025    LessThanOrEqualTo,
1026    GreaterThanOrEqualTo,
1027    NotEqual,
1028    Like,
1029    NotLike,
1030    QuantifiedLike,
1031    QuantifiedNotLike,
1032    Between,
1033    NotBetween,
1034    In,
1035    NotIn,
1036    IsDistinctFrom,
1037    IsNotDistinctFrom,
1038    And,
1039    Or,
1040    ArrayIndex,
1041    FieldAccess,
1042}
1043
1044#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
1045pub enum LikeQuantifier {
1046    Any,
1047    Some,
1048    All,
1049}
1050
1051#[derive(Debug, Clone, Serialize, Deserialize)]
1052pub enum QuantifiedLikeExprPattern {
1053    ExprList { exprs: Vec<Expr> },
1054    ArrayUnnest { expr: Box<Expr> },
1055}
1056
1057#[derive(Debug, Clone, Serialize, Deserialize)]
1058pub struct QuantifiedLikeExpr {
1059    pub quantifier: LikeQuantifier,
1060    pub pattern: QuantifiedLikeExprPattern,
1061}
1062
1063#[derive(Debug, Clone, Serialize, Deserialize)]
1064pub struct GroupingExpr {
1065    pub expr: Box<Expr>,
1066}
1067
1068#[derive(Debug, Clone, Serialize, Deserialize)]
1069pub struct ArrayExpr {
1070    pub r#type: Option<Type>,
1071    pub exprs: Vec<Expr>,
1072}
1073
1074#[derive(Debug, Clone, Serialize, Deserialize)]
1075pub struct StructExpr {
1076    pub r#type: Option<Type>,
1077    pub fields: Vec<StructField>,
1078}
1079
1080#[derive(Debug, Clone, Serialize, Deserialize)]
1081pub struct StructField {
1082    pub expr: Expr,
1083    pub alias: Option<Name>,
1084}
1085
1086#[derive(Debug, Clone, Serialize, Deserialize)]
1087pub enum QueryExpr {
1088    Grouping(GroupingQueryExpr),
1089    Select(Box<SelectQueryExpr>),
1090    SetSelect(SetSelectQueryExpr),
1091}
1092
1093#[derive(Debug, Clone, Serialize, Deserialize)]
1094pub struct GroupingQueryExpr {
1095    pub with: Option<With>,
1096    pub query: Box<QueryExpr>,
1097    pub order_by: Option<OrderBy>,
1098    pub limit: Option<Limit>,
1099}
1100
1101#[derive(Debug, Clone, Serialize, Deserialize)]
1102pub struct SelectQueryExpr {
1103    pub with: Option<With>,
1104    pub select: Select,
1105    pub order_by: Option<OrderBy>,
1106    pub limit: Option<Limit>,
1107}
1108
1109#[derive(Debug, Clone, Serialize, Deserialize)]
1110pub struct SetSelectQueryExpr {
1111    pub with: Option<With>,
1112    pub left_query: Box<QueryExpr>,
1113    pub set_operator: SetQueryOperator,
1114    pub right_query: Box<QueryExpr>,
1115    pub order_by: Option<OrderBy>,
1116    pub limit: Option<Limit>,
1117}
1118
1119#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
1120pub enum SetQueryOperator {
1121    Union,
1122    UnionDistinct,
1123    IntersectDistinct,
1124    ExceptDistinct,
1125}
1126
1127#[derive(Debug, Clone, Serialize, Deserialize)]
1128pub struct OrderBy {
1129    pub exprs: Vec<OrderByExpr>,
1130}
1131
1132#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
1133pub enum OrderBySortDirection {
1134    Asc,
1135    Desc,
1136}
1137
1138#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
1139pub enum OrderByNulls {
1140    First,
1141    Last,
1142}
1143
1144#[derive(Debug, Clone, Serialize, Deserialize)]
1145pub struct OrderByExpr {
1146    pub expr: Expr,
1147    pub sort_direction: Option<OrderBySortDirection>,
1148    pub nulls: Option<OrderByNulls>,
1149}
1150
1151#[derive(Debug, Clone, Serialize, Deserialize)]
1152pub struct Limit {
1153    pub count: Box<Expr>,
1154    pub offset: Option<Box<Expr>>,
1155}
1156
1157#[derive(Debug, Clone, Serialize, Deserialize)]
1158pub struct With {
1159    pub ctes: Vec<Cte>,
1160}
1161
1162#[derive(Debug, Clone, Serialize, Deserialize)]
1163pub enum Cte {
1164    NonRecursive(NonRecursiveCte),
1165    Recursive(RecursiveCte),
1166}
1167
1168#[derive(Debug, Clone, Serialize, Deserialize)]
1169pub struct NonRecursiveCte {
1170    pub name: Name,
1171    pub query: QueryExpr,
1172}
1173
1174#[derive(Debug, Clone, Serialize, Deserialize)]
1175pub struct RecursiveCte {
1176    pub name: Name,
1177    pub base_query: QueryExpr,
1178    pub recursive_query: QueryExpr,
1179}
1180
1181#[derive(Debug, Clone, Serialize, Deserialize)]
1182pub struct Select {
1183    pub differential_privacy: Option<DifferentialPrivacy>,
1184    pub distinct: bool,
1185    pub table_value: Option<SelectTableValue>,
1186    pub exprs: Vec<SelectExpr>,
1187    pub from: Option<From>,
1188    pub r#where: Option<Where>,
1189    pub group_by: Option<GroupBy>,
1190    pub having: Option<Having>,
1191    pub qualify: Option<Qualify>,
1192    pub window: Option<Window>,
1193}
1194
1195#[derive(Debug, Clone, Serialize, Deserialize)]
1196pub struct DifferentialPrivacyOption {
1197    pub name: Name,
1198    pub value: Expr,
1199}
1200
1201#[derive(Debug, Clone, Serialize, Deserialize)]
1202pub struct DifferentialPrivacy {
1203    pub options: Vec<DifferentialPrivacyOption>,
1204}
1205
1206#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
1207pub enum SelectTableValue {
1208    Struct,
1209    Value,
1210}
1211
1212#[derive(Debug, Clone, Serialize, Deserialize)]
1213pub enum SelectExpr {
1214    Col(SelectColExpr),
1215    ColAll(SelectColAllExpr),
1216    All(SelectAllExpr),
1217}
1218
1219#[derive(Debug, Clone, Serialize, Deserialize)]
1220pub struct SelectColExpr {
1221    pub expr: Expr,
1222    pub alias: Option<Name>,
1223}
1224
1225#[derive(Debug, Clone, Serialize, Deserialize)]
1226pub struct SelectColAllExpr {
1227    pub expr: Expr,
1228    pub except: Option<Vec<Name>>,
1229}
1230
1231#[derive(Debug, Clone, Serialize, Deserialize)]
1232pub struct SelectAllExpr {
1233    pub except: Option<Vec<Name>>,
1234}
1235
1236#[derive(Debug, Clone, Serialize, Deserialize)]
1237pub struct From {
1238    pub expr: Box<FromExpr>,
1239}
1240
1241#[derive(Debug, Clone, Serialize, Deserialize)]
1242pub enum TableOperator {
1243    Pivot(Pivot),
1244    Unpivot(Unpivot),
1245}
1246
1247#[derive(Debug, Clone, Serialize, Deserialize)]
1248pub struct Pivot {
1249    pub aggregates: Vec<PivotAggregate>,
1250    pub input_column: Name,
1251    pub pivot_columns: Vec<PivotColumn>,
1252    pub alias: Option<Name>,
1253}
1254
1255#[derive(Debug, Clone, Serialize, Deserialize)]
1256pub struct PivotAggregate {
1257    pub expr: Expr,
1258    pub alias: Option<Name>,
1259}
1260
1261#[derive(Debug, Clone, Serialize, Deserialize)]
1262pub struct PivotColumn {
1263    pub expr: Expr,
1264    pub alias: Option<Name>,
1265}
1266
1267#[derive(Debug, Clone, Serialize, Deserialize)]
1268pub struct Unpivot {
1269    pub nulls: UnpivotNulls,
1270    pub kind: UnpivotKind,
1271    pub alias: Option<Name>,
1272}
1273
1274#[derive(Debug, Clone, Serialize, Deserialize)]
1275pub struct TableSample {
1276    pub percent: Expr,
1277}
1278
1279#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
1280pub enum UnpivotNulls {
1281    Include,
1282    Exclude,
1283}
1284
1285#[derive(Debug, Clone, Serialize, Deserialize)]
1286pub enum UnpivotKind {
1287    SingleColumn(SingleColumnUnpivot),
1288    MultiColumn(MultiColumnUnpivot),
1289}
1290
1291#[derive(Debug, Clone, Serialize, Deserialize)]
1292pub struct SingleColumnUnpivot {
1293    pub values_column: Name,
1294    pub name_column: Name,
1295    pub columns_to_unpivot: Vec<ColumnToUnpivot>,
1296}
1297
1298#[derive(Debug, Clone, Serialize, Deserialize)]
1299pub struct MultiColumnUnpivot {
1300    pub values_columns: Vec<Name>,
1301    pub name_column: Name,
1302    pub column_sets_to_unpivot: Vec<ColumnSetToUnpivot>,
1303}
1304
1305#[derive(Debug, Clone, Serialize, Deserialize)]
1306pub struct ColumnToUnpivot {
1307    pub name: Name,
1308    pub alias: Option<Expr>,
1309}
1310
1311#[derive(Debug, Clone, Serialize, Deserialize)]
1312pub struct ColumnSetToUnpivot {
1313    pub names: Vec<Name>,
1314    pub alias: Option<Expr>,
1315}
1316
1317#[derive(Debug, Clone, Serialize, Deserialize)]
1318pub enum FromExpr {
1319    Join(JoinExpr),
1320    FullJoin(JoinExpr),
1321    LeftJoin(JoinExpr),
1322    RightJoin(JoinExpr),
1323    CrossJoin(CrossJoinExpr),
1324    Path(FromPathExpr),
1325    TableFunction(TableFunctionExpr),
1326    Unnest(FromUnnestExpr),
1327    GroupingQuery(FromGroupingQueryExpr),
1328    GroupingFrom(GroupingFromExpr),
1329}
1330
1331#[derive(Debug, Clone, Serialize, Deserialize)]
1332pub struct TableFunctionExpr {
1333    pub name: PathName,
1334    pub arguments: Vec<TableFunctionArgument>,
1335    pub alias: Option<Name>,
1336    pub table_operator: Option<TableOperator>,
1337    pub table_sample: Option<TableSample>,
1338}
1339
1340#[derive(Debug, Clone, Serialize, Deserialize)]
1341pub enum TableFunctionArgument {
1342    Table(PathName),
1343    Expr(Expr),
1344}
1345
1346#[derive(Debug, Clone, Serialize, Deserialize)]
1347pub struct CrossJoinExpr {
1348    pub left: Box<FromExpr>,
1349    pub right: Box<FromExpr>,
1350}
1351
1352#[derive(Debug, Clone, Serialize, Deserialize)]
1353pub struct JoinExpr {
1354    pub kind: JoinKind,
1355    pub left: Box<FromExpr>,
1356    pub right: Box<FromExpr>,
1357    pub cond: JoinCondition,
1358}
1359
1360#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
1361pub enum JoinKind {
1362    Inner,
1363    Left,
1364    Right,
1365    Full,
1366}
1367
1368#[derive(Debug, Clone, Serialize, Deserialize)]
1369pub enum JoinCondition {
1370    On(Expr),
1371    Using { columns: Vec<Name> },
1372}
1373
1374#[derive(Debug, Clone, Serialize, Deserialize)]
1375pub struct FromUnnestExpr {
1376    pub array: Box<Expr>,
1377    pub alias: Option<Name>,
1378    pub with_offset: bool,
1379    pub offset_alias: Option<Name>,
1380}
1381
1382#[derive(Debug, Clone, Serialize, Deserialize)]
1383pub struct FromPathExpr {
1384    pub path: PathName,
1385    pub alias: Option<Name>,
1386    pub system_time: Option<Expr>,
1387    pub table_operator: Option<TableOperator>,
1388    pub table_sample: Option<TableSample>,
1389}
1390
1391#[derive(Debug, Clone, Serialize, Deserialize)]
1392pub struct GroupingFromExpr {
1393    pub query: Box<FromExpr>,
1394}
1395
1396#[derive(Debug, Clone, Serialize, Deserialize)]
1397pub struct FromGroupingQueryExpr {
1398    pub query: Box<QueryExpr>,
1399    pub alias: Option<Name>,
1400    pub table_operator: Option<TableOperator>,
1401    pub table_sample: Option<TableSample>,
1402}
1403
1404#[derive(Debug, Clone, Serialize, Deserialize)]
1405pub struct Where {
1406    pub expr: Box<Expr>,
1407}
1408
1409#[derive(Debug, Clone, Serialize, Deserialize)]
1410pub enum GroupByExpr {
1411    Items { exprs: Vec<Expr> },
1412    All,
1413}
1414
1415#[derive(Debug, Clone, Serialize, Deserialize)]
1416pub struct GroupBy {
1417    pub expr: GroupByExpr,
1418}
1419
1420#[derive(Debug, Clone, Serialize, Deserialize)]
1421pub struct Having {
1422    pub expr: Box<Expr>,
1423}
1424
1425#[derive(Debug, Clone, Serialize, Deserialize)]
1426pub struct Qualify {
1427    pub expr: Box<Expr>,
1428}
1429
1430#[derive(Debug, Clone, Serialize, Deserialize)]
1431pub struct Window {
1432    pub named_windows: Vec<NamedWindow>,
1433}
1434
1435#[derive(Debug, Clone, Serialize, Deserialize)]
1436pub struct WindowOrderByExpr {
1437    pub expr: Expr,
1438    pub sort_direction: Option<OrderBySortDirection>,
1439    pub nulls: Option<OrderByNulls>,
1440}
1441
1442#[derive(Debug, Clone, Serialize, Deserialize)]
1443pub struct NamedWindow {
1444    pub name: Name,
1445    pub window: NamedWindowExpr,
1446}
1447
1448#[derive(Debug, Clone, Serialize, Deserialize)]
1449pub enum NamedWindowExpr {
1450    Reference(Name),
1451    WindowSpec(WindowSpec),
1452}
1453
1454#[derive(Debug, Clone, Serialize, Deserialize)]
1455pub struct WindowSpec {
1456    pub window_name: Option<Name>,
1457    pub partition_by: Option<Vec<Expr>>,
1458    pub order_by: Option<Vec<WindowOrderByExpr>>,
1459    pub frame: Option<WindowFrame>,
1460}
1461
1462#[derive(Debug, Clone, Serialize, Deserialize)]
1463pub struct WindowFrame {
1464    pub kind: WindowFrameKind,
1465    pub start: Option<FrameBound>,
1466    pub end: Option<FrameBound>,
1467}
1468
1469#[derive(Debug, Clone, Serialize, Deserialize)]
1470pub enum FrameBound {
1471    UnboundedPreceding,
1472    Preceding(String),
1473    UnboundedFollowing,
1474    Following(String),
1475    CurrentRow,
1476}
1477
1478#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
1479pub enum WindowFrameKind {
1480    Range,
1481    Rows,
1482}
1483
1484#[derive(PartialEq, Clone, Debug, EnumDiscriminants, Serialize, Deserialize)]
1485#[strum_discriminants(name(TokenTypeVariant))]
1486pub enum TokenType {
1487    LeftParen,
1488    RightParen,
1489    LeftSquare,
1490    RightSquare,
1491    Comma,
1492    Dot,
1493    Minus,
1494    Plus,
1495    BitwiseNot,
1496    BitwiseOr,
1497    BitwiseAnd,
1498    BitwiseXor,
1499    BitwiseRightShift,
1500    BitwiseLeftShift,
1501    Colon,
1502    Semicolon,
1503    Slash,
1504    Star,
1505    Tick,
1506    ConcatOperator,
1507    Bang,
1508    BangEqual,
1509    Equal,
1510    NotEqual,
1511    Greater,
1512    GreaterEqual,
1513    Less,
1514    LessEqual,
1515    RightArrow,
1516    QuotedIdentifier(String),
1517    Identifier(String),
1518    String(String),
1519    RawString(String),
1520    Bytes(String),
1521    RawBytes(String),
1522    Number(String),
1523    QueryNamedParameter(String),
1524    QueryPositionalParameter,
1525    SystemVariable(String),
1526    Eof,
1527
1528    // Reserved Keywords
1529    All,
1530    And,
1531    Any,
1532    Array,
1533    As,
1534    Asc,
1535    AssertRowsModified,
1536    At,
1537    Between,
1538    By,
1539    Case,
1540    Cast,
1541    Collate,
1542    Contains,
1543    Create,
1544    Cross,
1545    Cube,
1546    Current,
1547    Default,
1548    Define,
1549    Desc,
1550    Distinct,
1551    Else,
1552    End,
1553    Enum,
1554    Escape,
1555    Except,
1556    Exclude,
1557    Exists,
1558    Extract,
1559    False,
1560    Fetch,
1561    Following,
1562    For,
1563    From,
1564    Full,
1565    Group,
1566    Grouping,
1567    Groups,
1568    Hash,
1569    Having,
1570    If,
1571    Ignore,
1572    In,
1573    Inner,
1574    Intersect,
1575    Interval,
1576    Into,
1577    Is,
1578    Join,
1579    Lateral,
1580    Left,
1581    Like,
1582    Limit,
1583    Lookup,
1584    Merge,
1585    Natural,
1586    New,
1587    No,
1588    Not,
1589    Null,
1590    Nulls,
1591    Of,
1592    On,
1593    Or,
1594    Order,
1595    Outer,
1596    Over,
1597    Partition,
1598    Preceding,
1599    Proto,
1600    Qualify,
1601    Range,
1602    Recursive,
1603    Respect,
1604    Right,
1605    Rollup,
1606    Rows,
1607    Select,
1608    Set,
1609    Some,
1610    Struct,
1611    Tablesample,
1612    Then,
1613    To,
1614    Treat,
1615    True,
1616    Union,
1617    Unnest,
1618    Using,
1619    When,
1620    Where,
1621    Window,
1622    With,
1623    Within,
1624}
1625
1626impl TokenTypeVariant {
1627    pub(crate) fn variant_str(&self) -> &str {
1628        match self {
1629            TokenTypeVariant::LeftParen => "(",
1630            TokenTypeVariant::RightParen => ")",
1631            TokenTypeVariant::LeftSquare => "[",
1632            TokenTypeVariant::RightSquare => "]",
1633            TokenTypeVariant::Comma => ",",
1634            TokenTypeVariant::Dot => ".",
1635            TokenTypeVariant::Minus => "-",
1636            TokenTypeVariant::Plus => "+",
1637            TokenTypeVariant::BitwiseNot => "~",
1638            TokenTypeVariant::BitwiseOr => "|",
1639            TokenTypeVariant::BitwiseAnd => "&",
1640            TokenTypeVariant::BitwiseXor => "^",
1641            TokenTypeVariant::BitwiseRightShift => ">>",
1642            TokenTypeVariant::BitwiseLeftShift => "<<",
1643            TokenTypeVariant::Colon => ":",
1644            TokenTypeVariant::Semicolon => ";",
1645            TokenTypeVariant::Slash => "/",
1646            TokenTypeVariant::Star => "*",
1647            TokenTypeVariant::Tick => "`",
1648            TokenTypeVariant::ConcatOperator => "||",
1649            TokenTypeVariant::Bang => "!",
1650            TokenTypeVariant::BangEqual => "!=",
1651            TokenTypeVariant::Equal => "=",
1652            TokenTypeVariant::NotEqual => "<>",
1653            TokenTypeVariant::Greater => ">",
1654            TokenTypeVariant::GreaterEqual => ">=",
1655            TokenTypeVariant::Less => "<",
1656            TokenTypeVariant::LessEqual => "<=",
1657            TokenTypeVariant::RightArrow => "=>",
1658            TokenTypeVariant::QuotedIdentifier => "QuotedIdentifier",
1659            TokenTypeVariant::Identifier => "Identifier",
1660            TokenTypeVariant::String => "String",
1661            TokenTypeVariant::RawString => "RawString",
1662            TokenTypeVariant::Bytes => "Bytes",
1663            TokenTypeVariant::RawBytes => "RawBytes",
1664            TokenTypeVariant::Number => "Number",
1665            TokenTypeVariant::Eof => "EOF",
1666            TokenTypeVariant::QueryNamedParameter => "QueryNamedParameter",
1667            TokenTypeVariant::QueryPositionalParameter => "QueryPositionalParameter",
1668            TokenTypeVariant::SystemVariable => "SystemVariable",
1669
1670            // Reserved Keywords
1671            TokenTypeVariant::All => "ALL",
1672            TokenTypeVariant::And => "AND",
1673            TokenTypeVariant::Any => "ANY",
1674            TokenTypeVariant::Array => "ARRAY",
1675            TokenTypeVariant::As => "AS",
1676            TokenTypeVariant::Asc => "ASC",
1677            TokenTypeVariant::AssertRowsModified => "ASSERT_ROWS_MODIFIED",
1678            TokenTypeVariant::At => "AT",
1679            TokenTypeVariant::Between => "BETWEEN",
1680            TokenTypeVariant::By => "BY",
1681            TokenTypeVariant::Case => "CASE",
1682            TokenTypeVariant::Cast => "CAST",
1683            TokenTypeVariant::Collate => "COLLATE",
1684            TokenTypeVariant::Contains => "CONTAINS",
1685            TokenTypeVariant::Create => "CREATE",
1686            TokenTypeVariant::Cross => "CROSS",
1687            TokenTypeVariant::Cube => "CUBE",
1688            TokenTypeVariant::Current => "CURRENT",
1689            TokenTypeVariant::Default => "DEFAULT",
1690            TokenTypeVariant::Define => "DEFINE",
1691            TokenTypeVariant::Desc => "DESC",
1692            TokenTypeVariant::Distinct => "DISTINCT",
1693            TokenTypeVariant::Else => "ELSE",
1694            TokenTypeVariant::End => "END",
1695            TokenTypeVariant::Enum => "ENUM",
1696            TokenTypeVariant::Escape => "ESCAPE",
1697            TokenTypeVariant::Except => "EXCEPT",
1698            TokenTypeVariant::Exclude => "EXCLUDE",
1699            TokenTypeVariant::Exists => "EXISTS",
1700            TokenTypeVariant::Extract => "EXTRACT",
1701            TokenTypeVariant::False => "FALSE",
1702            TokenTypeVariant::Fetch => "FETCH",
1703            TokenTypeVariant::Following => "FOLLOWING",
1704            TokenTypeVariant::For => "FOR",
1705            TokenTypeVariant::From => "FROM",
1706            TokenTypeVariant::Full => "FULL",
1707            TokenTypeVariant::Group => "GROUP",
1708            TokenTypeVariant::Grouping => "GROUPING",
1709            TokenTypeVariant::Groups => "GROUPS",
1710            TokenTypeVariant::Hash => "HASH",
1711            TokenTypeVariant::Having => "HAVING",
1712            TokenTypeVariant::If => "IF",
1713            TokenTypeVariant::Ignore => "IGNORE",
1714            TokenTypeVariant::In => "IN",
1715            TokenTypeVariant::Inner => "INNER",
1716            TokenTypeVariant::Intersect => "INTERSECT",
1717            TokenTypeVariant::Interval => "INTERVAL",
1718            TokenTypeVariant::Into => "INTO",
1719            TokenTypeVariant::Is => "IS",
1720            TokenTypeVariant::Join => "JOIN",
1721            TokenTypeVariant::Lateral => "LATERAL",
1722            TokenTypeVariant::Left => "LEFT",
1723            TokenTypeVariant::Like => "LIKE",
1724            TokenTypeVariant::Limit => "LIMIT",
1725            TokenTypeVariant::Lookup => "LOOKUP",
1726            TokenTypeVariant::Merge => "MERGE",
1727            TokenTypeVariant::Natural => "NATURAL",
1728            TokenTypeVariant::New => "NEW",
1729            TokenTypeVariant::No => "NO",
1730            TokenTypeVariant::Not => "NOT",
1731            TokenTypeVariant::Null => "NULL",
1732            TokenTypeVariant::Nulls => "NULLS",
1733            TokenTypeVariant::Of => "OF",
1734            TokenTypeVariant::On => "ON",
1735            TokenTypeVariant::Or => "OR",
1736            TokenTypeVariant::Order => "ORDER",
1737            TokenTypeVariant::Outer => "OUTER",
1738            TokenTypeVariant::Over => "OVER",
1739            TokenTypeVariant::Partition => "PARTITION",
1740            TokenTypeVariant::Preceding => "PRECEDING",
1741            TokenTypeVariant::Proto => "PROTO",
1742            TokenTypeVariant::Qualify => "QUALIFY",
1743            TokenTypeVariant::Range => "RANGE",
1744            TokenTypeVariant::Recursive => "RECURSIVE",
1745            TokenTypeVariant::Respect => "RESPECT",
1746            TokenTypeVariant::Right => "RIGHT",
1747            TokenTypeVariant::Rollup => "ROLLUP",
1748            TokenTypeVariant::Rows => "ROWS",
1749            TokenTypeVariant::Select => "SELECT",
1750            TokenTypeVariant::Set => "SET",
1751            TokenTypeVariant::Some => "SOME",
1752            TokenTypeVariant::Struct => "STRUCT",
1753            TokenTypeVariant::Tablesample => "TABLESAMPLE",
1754            TokenTypeVariant::Then => "THEN",
1755            TokenTypeVariant::To => "TO",
1756            TokenTypeVariant::Treat => "TREAT",
1757            TokenTypeVariant::True => "TRUE",
1758            TokenTypeVariant::Union => "UNION",
1759            TokenTypeVariant::Unnest => "UNNEST",
1760            TokenTypeVariant::Using => "USING",
1761            TokenTypeVariant::When => "WHEN",
1762            TokenTypeVariant::Where => "WHERE",
1763            TokenTypeVariant::Window => "WINDOW",
1764            TokenTypeVariant::With => "WITH",
1765            TokenTypeVariant::Within => "WITHIN",
1766        }
1767    }
1768}
1769
1770#[derive(Debug, Clone, Serialize, Deserialize)]
1771pub struct Token {
1772    pub kind: TokenType,
1773    pub lexeme: String,
1774    pub line: u32,
1775    pub col: u32,
1776}
inbq/ast.rs

inbq/
ast.rs
