diff --git a/PLAN.md b/PLAN.md
index b3402962..abaf8eac 100644
--- a/PLAN.md
+++ b/PLAN.md
@@ -206,6 +206,23 @@ type checking should allow us to give type errors without the user having to run
 
 support more advanced lint rules
 
+#### type check `create type t as range`
+
+```sql
+create type timerange as range (
+  subtype = time,
+  subtype_diff = time_subtype_diff
+);
+```
+
+if set, `subtype_diff` must be of type `function time_subtype_diff(time without time zone, time without time zone)`
+
+```ts
+function createRangeType<T>(subtype: T, subtype_diff: (T, T) => float8)
+```
+
+https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-DEFINING
+
 ### PGO
 
 - https://github.com/rust-lang/rust-analyzer/pull/19582#issue-2992471459
@@ -590,6 +607,26 @@ select '{"foo": 1,}'::json;
 --               ^ invalid json, unexpected trailing comma
 ```
 
+```sql
+create type foo as (
+  a int8,
+  b int8
+);
+select foo '(1)';
+--            ^ malformed record literal, missing column b
+```
+
+```sql
+select '[1,,2)'::numrange;
+--         ^ malformed range literal, extra comma
+
+create table reservation (room int, during tsrange);
+insert into reservation values
+    (1108, '[2010-01-01 14:30,, 2010-01-01 15:30)');
+--                            ^ malformed range literal, extra comma
+
+```
+
 ### Rule: column label is the same as an existing column
 
 ```sql
@@ -772,6 +809,18 @@ select * from json_table(
 );
 ```
 
+#### `nextval`
+
+```sql
+-- via https://www.postgresql.org/docs/current/datatype-oid.html
+nextval('foo')              -- operates on sequence foo
+nextval('FOO')              -- same as above
+nextval('"Foo"')            -- operates on sequence Foo
+nextval('myschema.foo')     -- operates on myschema.foo
+nextval('"myschema".foo')   -- same as above
+nextval('foo')              -- searches search path for foo
+```
+
 ### Autocomplete
 
 - [datagrip postfix completion](https://blog.jetbrains.com/datagrip/2019/03/11/top-9-sql-features-of-datagrip-you-have-to-know/#postfix_completion)
diff --git a/crates/squawk_ide/src/expand_selection.rs b/crates/squawk_ide/src/expand_selection.rs
index e7eee024..84282a6c 100644
--- a/crates/squawk_ide/src/expand_selection.rs
+++ b/crates/squawk_ide/src/expand_selection.rs
@@ -54,6 +54,8 @@ const DELIMITED_LIST_KINDS: &[SyntaxKind] = &[
     SyntaxKind::REVOKE_COMMAND_LIST,
     SyntaxKind::ROLE_LIST,
     SyntaxKind::ROW_LIST,
+    SyntaxKind::XML_ATTRIBUTE_LIST,
+    SyntaxKind::XML_NAMESPACE_LIST,
     SyntaxKind::SET_COLUMN_LIST,
     SyntaxKind::SET_EXPR_LIST,
     SyntaxKind::SET_OPTIONS_LIST,
diff --git a/crates/squawk_parser/src/generated/syntax_kind.rs b/crates/squawk_parser/src/generated/syntax_kind.rs
index 2a33fc41..bf8c57e2 100644
--- a/crates/squawk_parser/src/generated/syntax_kind.rs
+++ b/crates/squawk_parser/src/generated/syntax_kind.rs
@@ -547,6 +547,7 @@ pub enum SyntaxKind {
     ADD_OP_CLASS_OPTIONS,
     AGGREGATE,
     ALIAS,
+    ALL_FN,
     ALTER_AGGREGATE,
     ALTER_COLLATION,
     ALTER_COLUMN,
@@ -595,6 +596,7 @@ pub enum SyntaxKind {
     ALTER_USER_MAPPING,
     ALTER_VIEW,
     ANALYZE,
+    ANY_FN,
     ARG,
     ARG_LIST,
     ARRAY_EXPR,
@@ -643,7 +645,6 @@ pub enum SyntaxKind {
     CONSTRAINT_INCLUDE_CLAUSE,
     CONSTRAINT_INDEX_METHOD,
     CONSTRAINT_INDEX_TABLESPACE,
-    CONSTRAINT_WHERE_CLAUSE,
     COPY,
     COST_FUNC_OPTION,
     CREATE_ACCESS_METHOD,
@@ -774,8 +775,11 @@ pub enum SyntaxKind {
     EXCEPT_TABLES,
     EXCLUDE_CONSTRAINT,
     EXECUTE,
+    EXISTS_FN,
     EXPLAIN,
+    EXPR_AS_NAME,
     EXPR_TYPE,
+    EXTRACT_FN,
     FAT_ARROW,
     FDW_OPTION,
     FDW_OPTION_LIST,
@@ -842,6 +846,9 @@ pub enum SyntaxKind {
     JOIN_LEFT,
     JOIN_RIGHT,
     JOIN_USING_CLAUSE,
+    JSON_ARRAY_AGG_FN,
+    JSON_ARRAY_FN,
+    JSON_BEHAVIOR_CLAUSE,
     JSON_BEHAVIOR_DEFAULT,
     JSON_BEHAVIOR_EMPTY_ARRAY,
     JSON_BEHAVIOR_EMPTY_OBJECT,
@@ -850,19 +857,32 @@ pub enum SyntaxKind {
     JSON_BEHAVIOR_NULL,
     JSON_BEHAVIOR_TRUE,
     JSON_BEHAVIOR_UNKNOWN,
+    JSON_ENCODING_CLAUSE,
+    JSON_EXISTS_FN,
+    JSON_EXPR_FORMAT,
+    JSON_FN,
     JSON_FORMAT_CLAUSE,
     JSON_KEYS_UNIQUE_CLAUSE,
     JSON_KEY_VALUE,
     JSON_NULL_CLAUSE,
+    JSON_OBJECT_AGG_FN,
+    JSON_OBJECT_FN,
     JSON_ON_EMPTY_CLAUSE,
     JSON_ON_ERROR_CLAUSE,
     JSON_PASSING_ARG,
     JSON_PASSING_CLAUSE,
+    JSON_PATH_CLAUSE,
+    JSON_QUERY_FN,
     JSON_QUOTES_CLAUSE,
     JSON_RETURNING_CLAUSE,
+    JSON_SCALAR_FN,
+    JSON_SELECT_FORMAT,
+    JSON_SERIALIZE_FN,
+    JSON_TABLE,
     JSON_TABLE_COLUMN,
     JSON_TABLE_COLUMN_LIST,
     JSON_VALUE_EXPR,
+    JSON_VALUE_FN,
     JSON_WRAPPER_BEHAVIOR_CLAUSE,
     LANGUAGE_FUNC_OPTION,
     LEAKPROOF_FUNC_OPTION,
@@ -935,6 +955,7 @@ pub enum SyntaxKind {
     OP_SIG_LIST,
     ORDER_BY_CLAUSE,
     OR_REPLACE,
+    OVERLAY_FN,
     OVER_CLAUSE,
     OWNER_TO,
     PARALLEL_FUNC_OPTION,
@@ -960,6 +981,7 @@ pub enum SyntaxKind {
     PATH_TYPE,
     PERCENT_TYPE,
     PERCENT_TYPE_CLAUSE,
+    POSITION_FN,
     POSTFIX_EXPR,
     PREFIX_EXPR,
     PREPARE,
@@ -968,6 +990,7 @@ pub enum SyntaxKind {
     PRIMARY_KEY_CONSTRAINT,
     PRIVILEGES,
     PRIVILEGE_TARGET,
+    PUBLICATION_OBJECT,
     READ_COMMITTED,
     READ_ONLY,
     READ_UNCOMMITTED,
@@ -985,6 +1008,7 @@ pub enum SyntaxKind {
     RENAME_COLUMN,
     RENAME_CONSTRAINT,
     RENAME_TO,
+    REPEATABLE_CLAUSE,
     REPEATABLE_READ,
     REPLICA_IDENTITY,
     RESET,
@@ -1058,6 +1082,7 @@ pub enum SyntaxKind {
     SHOW,
     SIMILAR_TO,
     SLICE_EXPR,
+    SOME_FN,
     SORT_ASC,
     SORT_BY,
     SORT_BY_LIST,
@@ -1066,8 +1091,10 @@ pub enum SyntaxKind {
     SOURCE_FILE,
     STORAGE,
     STRICT_FUNC_OPTION,
+    SUBSTRING_FN,
     SUPPORT_FUNC_OPTION,
     TABLE,
+    TABLESAMPLE_CLAUSE,
     TABLESPACE,
     TABLE_ARG_LIST,
     TABLE_LIST,
@@ -1082,6 +1109,7 @@ pub enum SyntaxKind {
     TRIGGER_EVENT,
     TRIGGER_EVENT_LIST,
     TRIGGER_EVENT_UPDATE,
+    TRIM_FN,
     TRUNCATE,
     TUPLE_EXPR,
     UNICODE_NORMAL_FORM,
@@ -1104,6 +1132,7 @@ pub enum SyntaxKind {
     WHEN_CLAUSE_LIST,
     WHEN_CONDITION,
     WHERE_CLAUSE,
+    WHERE_CONDITION_CLAUSE,
     WHERE_CURRENT_OF,
     WINDOW_CLAUSE,
     WINDOW_DEF,
@@ -1119,8 +1148,21 @@ pub enum SyntaxKind {
     WITH_PARAMS,
     WITH_TABLE,
     WITH_TIMEZONE,
+    XML_ATTRIBUTE_LIST,
     XML_COLUMN_OPTION,
     XML_COLUMN_OPTION_LIST,
+    XML_ELEMENT_FN,
+    XML_EXISTS_FN,
+    XML_FOREST_FN,
+    XML_NAMESPACE,
+    XML_NAMESPACE_LIST,
+    XML_PARSE_FN,
+    XML_PASSING_MECH,
+    XML_PI_FN,
+    XML_ROOT_FN,
+    XML_ROW_PASSING_CLAUSE,
+    XML_SERIALIZE_FN,
+    XML_TABLE,
     XML_TABLE_COLUMN,
     XML_TABLE_COLUMN_LIST,
 
diff --git a/crates/squawk_parser/src/grammar.rs b/crates/squawk_parser/src/grammar.rs
index 9530438f..1e0b739f 100644
--- a/crates/squawk_parser/src/grammar.rs
+++ b/crates/squawk_parser/src/grammar.rs
@@ -247,13 +247,18 @@ fn extract_arg(p: &mut Parser<'_>) {
 
 fn extract_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(EXTRACT_KW));
-    custom_fn(p, EXTRACT_KW, |p| {
-        extract_arg(p);
-        p.expect(FROM_KW);
-        if expr(p).is_none() {
-            p.error("expected an expression");
-        }
-    })
+    let m = p.start();
+    p.expect(EXTRACT_KW);
+    p.expect(L_PAREN);
+    extract_arg(p);
+    p.expect(FROM_KW);
+    if expr(p).is_none() {
+        p.error("expected an expression");
+    }
+    p.expect(R_PAREN);
+    let m = m.complete(p, EXTRACT_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // | OVERLAY '(' overlay_list ')'
@@ -263,10 +268,10 @@ fn extract_fn(p: &mut Parser<'_>) -> CompletedMarker {
 // | OVERLAY '(' func_arg_list_opt ')
 fn overlay_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(OVERLAY_KW));
-    custom_fn(p, OVERLAY_KW, |p| {
-        if p.at(R_PAREN) {
-            return;
-        }
+    let m = p.start();
+    p.expect(OVERLAY_KW);
+    p.expect(L_PAREN);
+    if !p.at(R_PAREN) {
         if expr(p).is_none() {
             p.error("expected an expression");
         }
@@ -282,9 +287,13 @@ fn overlay_fn(p: &mut Parser<'_>) -> CompletedMarker {
                 p.error("expected an expression");
             }
         } else if p.eat(COMMA) {
-            expr_list(p);
+            opt_expr_list(p);
         }
-    })
+    }
+    p.expect(R_PAREN);
+    let m = m.complete(p, OVERLAY_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // POSITION '(' position_list ')'
@@ -305,41 +314,51 @@ fn position_fn(p: &mut Parser<'_>) -> CompletedMarker {
             },
         )
     }
-    custom_fn(p, POSITION_KW, |p| {
-        if b_expr(p).is_none() {
-            p.error("expected an expression");
-        }
-        p.expect(IN_KW);
-        if b_expr(p).is_none() {
-            p.error("expected an expression");
-        }
-    })
+    let m = p.start();
+    p.expect(POSITION_KW);
+    p.expect(L_PAREN);
+    if b_expr(p).is_none() {
+        p.error("expected an expression");
+    }
+    p.expect(IN_KW);
+    if b_expr(p).is_none() {
+        p.error("expected an expression");
+    }
+    p.expect(R_PAREN);
+    let m = m.complete(p, POSITION_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 fn trim_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(TRIM_KW));
-    custom_fn(p, TRIM_KW, |p| {
-        let _ = p.eat(BOTH_KW) || p.eat(LEADING_KW) || p.eat(TRAILING_KW);
-        // | FROM expr_list
-        // | a_expr FROM expr_list
-        // | expr_list
+    let m = p.start();
+    p.expect(TRIM_KW);
+    p.expect(L_PAREN);
+    let _ = p.eat(BOTH_KW) || p.eat(LEADING_KW) || p.eat(TRAILING_KW);
+    // | FROM expr_list
+    // | a_expr FROM expr_list
+    // | expr_list
+    if p.eat(FROM_KW) {
+        if !opt_expr_list(p) {
+            p.error("expected expression")
+        }
+    } else {
+        if expr(p).is_none() {
+            p.error("expected expression");
+        }
         if p.eat(FROM_KW) {
-            if !expr_list(p) {
-                p.error("expected expression")
-            }
+            opt_expr_list(p);
         } else {
-            if expr(p).is_none() {
-                p.error("expected expression");
-            }
-            if p.eat(FROM_KW) {
-                expr_list(p);
-            } else {
-                if p.eat(COMMA) {
-                    expr_list(p);
-                }
+            if p.eat(COMMA) {
+                opt_expr_list(p);
             }
-        };
-    })
+        }
+    };
+    p.expect(R_PAREN);
+    let m = m.complete(p, TRIM_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // SUBSTRING '(' substr_list ')'
@@ -353,48 +372,53 @@ fn trim_fn(p: &mut Parser<'_>) -> CompletedMarker {
 // SUBSTRING '(' func_arg_list_opt ')'
 fn substring_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(SUBSTRING_KW));
-    custom_fn(p, SUBSTRING_KW, |p| {
-        if expr(p).is_none() {
-            p.error("expected an expression");
-        }
-        match p.current() {
-            // FOR a_expr FROM a_expr
-            // FOR a_expr
-            FOR_KW => {
-                p.bump(FOR_KW);
-                if expr(p).is_none() {
-                    p.error("expected an expression");
-                }
-                // [ from expr ]
-                if p.eat(FROM_KW) && expr(p).is_none() {
-                    p.error("expected an expression");
-                }
+    let m = p.start();
+    p.expect(SUBSTRING_KW);
+    p.expect(L_PAREN);
+    if expr(p).is_none() {
+        p.error("expected an expression");
+    }
+    match p.current() {
+        // FOR a_expr FROM a_expr
+        // FOR a_expr
+        FOR_KW => {
+            p.bump(FOR_KW);
+            if expr(p).is_none() {
+                p.error("expected an expression");
             }
-            // FROM a_expr
-            // FROM a_expr FOR a_expr
-            FROM_KW => {
-                p.bump(FROM_KW);
-                if expr(p).is_none() {
-                    p.error("expected an expression");
-                }
-                // [ for expr ]
-                if p.eat(FOR_KW) && expr(p).is_none() {
-                    p.error("expected an expression");
-                }
+            // [ from expr ]
+            if p.eat(FROM_KW) && expr(p).is_none() {
+                p.error("expected an expression");
             }
-            // SIMILAR a_expr ESCAPE a_expr
-            SIMILAR_KW => {
-                p.bump(SIMILAR_KW);
-                if expr(p).is_none() {
-                    p.error("expected an expression");
-                }
+        }
+        // FROM a_expr
+        // FROM a_expr FOR a_expr
+        FROM_KW => {
+            p.bump(FROM_KW);
+            if expr(p).is_none() {
+                p.error("expected an expression");
             }
-            _ if p.eat(COMMA) => {
-                expr_list(p);
+            // [ for expr ]
+            if p.eat(FOR_KW) && expr(p).is_none() {
+                p.error("expected an expression");
             }
-            _ => {}
         }
-    })
+        // SIMILAR a_expr ESCAPE a_expr
+        SIMILAR_KW => {
+            p.bump(SIMILAR_KW);
+            if expr(p).is_none() {
+                p.error("expected an expression");
+            }
+        }
+        _ if p.eat(COMMA) => {
+            opt_expr_list(p);
+        }
+        _ => {}
+    }
+    p.expect(R_PAREN);
+    let m = m.complete(p, SUBSTRING_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 fn opt_json_encoding_clause(p: &mut Parser<'_>) {
@@ -469,6 +493,15 @@ pub(crate) fn opt_json_keys_unique_clause(p: &mut Parser<'_>) {
     }
 }
 
+const JSON_OBJECT_FN_ARG_FOLLOW: TokenSet = TokenSet::new(&[
+    R_PAREN,
+    NULL_KW,
+    ABSENT_KW,
+    WITH_KW,
+    WITHOUT_KW,
+    RETURNING_KW,
+]);
+
 // json_object( func_arg_list )
 //   func_arg_list:  func_arg_expr
 //     | func_arg_list ',' func_arg_expr
@@ -506,16 +539,10 @@ fn json_object_fn_arg_list(p: &mut Parser<'_>) {
         // json_object(c_expr ,
         // json_object(a_expr :
         // json_object(a_expr value
-        json_object_arg(p);
+        json_key_value(p);
         // if we're at a the end of the params or the start of the optional
         // null_clause break
-        if p.at(R_PAREN)
-            || p.at(NULL_KW)
-            || p.at(ABSENT_KW)
-            || p.at(WITH_KW)
-            || p.at(WITHOUT_KW)
-            || p.at(RETURNING_KW)
-        {
+        if p.at_ts(JSON_OBJECT_FN_ARG_FOLLOW) {
             break;
         } else if p.at(COMMA) {
             // we're in a function arg
@@ -537,49 +564,40 @@ fn json_object_fn_arg_list(p: &mut Parser<'_>) {
 
 fn json_object_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(JSON_OBJECT_KW));
-    custom_fn(p, JSON_OBJECT_KW, |p| {
-        json_object_fn_arg_list(p);
-    })
+    let m = p.start();
+    p.expect(JSON_OBJECT_KW);
+    p.expect(L_PAREN);
+    json_object_fn_arg_list(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, JSON_OBJECT_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 fn json_objectagg_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(JSON_OBJECTAGG_KW));
-    custom_fn(p, JSON_OBJECTAGG_KW, |p| {
-        json_object_arg(p);
-        opt_json_null_clause(p);
-        opt_json_keys_unique_clause(p);
-        opt_json_returning_clause(p);
-    })
+    let m = p.start();
+    p.expect(JSON_OBJECTAGG_KW);
+    p.expect(L_PAREN);
+    json_key_value(p);
+    opt_json_null_clause(p);
+    opt_json_keys_unique_clause(p);
+    opt_json_returning_clause(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, JSON_OBJECT_AGG_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 /// <https://www.postgresql.org/docs/17/functions-json.html#FUNCTIONS-SQLJSON-TABLE>
 fn json_table_fn(p: &mut Parser<'_>) -> CompletedMarker {
-    custom_fn(p, JSON_TABLE_KW, |p| {
-        json_table_arg_list(p);
-    })
-}
-
-fn custom_fn(
-    p: &mut Parser<'_>,
-    name: SyntaxKind,
-    mut body: impl FnMut(&mut Parser<'_>),
-) -> CompletedMarker {
-    assert!(p.at(name));
+    assert!(p.at(JSON_TABLE_KW));
     let m = p.start();
-    let name_ref = p.start();
-    p.expect(name);
-    name_ref.complete(p, NAME_REF);
-
-    let args = p.start();
+    p.bump(JSON_TABLE_KW);
     p.expect(L_PAREN);
-    if !p.at(R_PAREN) {
-        body(p);
-    }
+    json_table_arg_list(p);
     p.expect(R_PAREN);
-    args.complete(p, ARG_LIST);
-
-    opt_agg_clauses(p);
-    m.complete(p, CALL_EXPR)
+    m.complete(p, JSON_TABLE)
 }
 
 // JSON_TABLE (
@@ -667,22 +685,12 @@ fn opt_json_table_column(p: &mut Parser<'_>) -> bool {
             type_name(p);
             // name type EXISTS [ PATH path_expression ]
             if p.eat(EXISTS_KW) {
-                // [ PATH path_expression ]
-                if p.eat(PATH_KW) {
-                    // path_expression
-                    if expr(p).is_none() {
-                        p.error("expected expression");
-                    }
-                }
+                opt_json_path_clause(p);
                 opt_json_behavior_clause(p);
             } else {
                 // [ FORMAT JSON [ENCODING UTF8]]
                 opt_json_format_clause(p);
-                // [ PATH path_expression ]
-                if p.eat(PATH_KW) {
-                    // path_expression
-                    string_literal(p);
-                }
+                opt_json_path_clause(p);
                 opt_json_wrapper_behavior(p);
                 opt_json_quotes_clause(p);
                 opt_json_behavior_clause(p);
@@ -693,6 +701,18 @@ fn opt_json_table_column(p: &mut Parser<'_>) -> bool {
     true
 }
 
+fn opt_json_path_clause(p: &mut Parser<'_>) {
+    let m = p.start();
+    // [ PATH path_expression ]
+    if p.eat(PATH_KW) {
+        // path_expression
+        string_literal(p);
+        m.complete(p, JSON_PATH_CLAUSE);
+    } else {
+        m.abandon(p);
+    }
+}
+
 // json_array (
 //  [ { value_expression [ FORMAT JSON ] } [, ...] ]
 //  [ { NULL | ABSENT } ON NULL ]
@@ -702,7 +722,7 @@ fn opt_json_table_column(p: &mut Parser<'_>) -> bool {
 //  [ query_expression ]
 //  [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ]
 // )
-fn json_array_fn_arg_list(p: &mut Parser<'_>) {
+fn opt_json_array_fn_arg_list(p: &mut Parser<'_>) {
     // 1, 2, 3, 4
     while !p.at(EOF) && !p.at(R_PAREN) && !p.at(RETURNING_KW) {
         if p.at_ts(SELECT_FIRST) {
@@ -724,17 +744,19 @@ fn json_array_fn_arg_list(p: &mut Parser<'_>) {
         }
     }
     opt_json_null_clause(p);
-    // (RETURNING Typename json_format_clause_opt)
-    if opt_json_returning_clause(p).is_none() && opt_json_format_clause(p).is_none() {
-        opt_json_encoding_clause(p);
-    }
+    opt_json_returning_clause(p);
 }
 
 fn json_array_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(JSON_ARRAY_KW));
-    custom_fn(p, JSON_ARRAY_KW, |p| {
-        json_array_fn_arg_list(p);
-    })
+    let m = p.start();
+    p.expect(JSON_ARRAY_KW);
+    p.expect(L_PAREN);
+    opt_json_array_fn_arg_list(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, JSON_ARRAY_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 /// <https://www.postgresql.org/docs/17/functions-comparisons.html#FUNCTIONS-COMPARISONS-ANY-SOME>
@@ -743,10 +765,14 @@ fn some_any_all_fn(p: &mut Parser<'_>) -> CompletedMarker {
     let m = p.start();
     // TODO: this can only be in the conext of a binary expression, so we should
     // have some validation for that.
-    let m1 = p.start();
     // SOME | ANY | ALL
+    let kind = match p.current() {
+        SOME_KW => SOME_FN,
+        ANY_KW => ANY_FN,
+        ALL_KW => ALL_FN,
+        _ => unreachable!(),
+    };
     p.bump_any();
-    m1.complete(p, NAME_REF);
     // args
     p.expect(L_PAREN);
     if p.at_ts(SELECT_FIRST) {
@@ -757,6 +783,8 @@ fn some_any_all_fn(p: &mut Parser<'_>) -> CompletedMarker {
         }
     }
     p.expect(R_PAREN);
+    let m = m.complete(p, kind).precede(p);
+    opt_agg_clauses(p);
     m.complete(p, CALL_EXPR)
 }
 
@@ -791,6 +819,7 @@ fn atom_expr(p: &mut Parser<'_>) -> Option<CompletedMarker> {
         (JSON_OBJECTAGG_KW, L_PAREN) => json_objectagg_fn(p),
         (JSON_ARRAYAGG_KW, L_PAREN) => json_arrayagg_fn(p),
         (JSON_QUERY_KW, L_PAREN) => json_query_fn(p),
+        (JSON_SCALAR_KW, L_PAREN) => json_scalar_fn(p),
         (JSON_SERIALIZE_KW, L_PAREN) => json_serialize_fn(p),
         (JSON_VALUE_KW, L_PAREN) => json_value_fn(p),
         (JSON_KW, L_PAREN) => json_fn(p),
@@ -829,39 +858,54 @@ fn atom_expr(p: &mut Parser<'_>) -> Option<CompletedMarker> {
 
 fn json_arrayagg_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(JSON_ARRAYAGG_KW));
-    custom_fn(p, JSON_ARRAYAGG_KW, |p| {
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        opt_json_format_clause(p);
-        opt_order_by_clause(p);
-        opt_json_null_clause(p);
-        opt_json_returning_clause(p);
-    })
+    let m = p.start();
+    p.expect(JSON_ARRAYAGG_KW);
+    p.expect(L_PAREN);
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    opt_json_format_clause(p);
+    opt_order_by_clause(p);
+    opt_json_null_clause(p);
+    opt_json_returning_clause(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, JSON_ARRAY_AGG_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 fn exists_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(EXISTS_KW));
-    custom_fn(p, EXISTS_KW, |p| {
-        if p.at_ts(SELECT_FIRST) {
-            select(p, None, &SelectRestrictions::default());
-        } else {
-            p.error("expected select")
-        }
-    })
+    let m = p.start();
+    p.bump(EXISTS_KW);
+    p.expect(L_PAREN);
+    if p.at_ts(SELECT_FIRST) {
+        select(p, None, &SelectRestrictions::default());
+    } else {
+        p.error("expected select");
+    }
+    p.expect(R_PAREN);
+    let m = m.complete(p, EXISTS_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // XMLPI '(' NAME_P ColLabel ',' a_expr ')'
 // XMLPI '(' NAME_P ColLabel ')'
 fn xmlpi_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(XMLPI_KW));
-    custom_fn(p, XMLPI_KW, |p| {
-        p.expect(NAME_KW);
-        col_label(p);
-        if p.eat(COMMA) && expr(p).is_none() {
-            p.error("expected expr");
-        }
-    })
+    let m = p.start();
+    p.expect(XMLPI_KW);
+    p.expect(L_PAREN);
+    p.expect(NAME_KW);
+    col_label(p);
+    if p.eat(COMMA) && expr(p).is_none() {
+        p.error("expected expr");
+    }
+    p.expect(R_PAREN);
+    let m = m.complete(p, XML_PI_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // XMLPARSE '(' document_or_content a_expr xml_whitespace_option ')'
@@ -874,41 +918,40 @@ fn xmlpi_fn(p: &mut Parser<'_>) -> CompletedMarker {
 //     | /*EMPTY*/
 fn xmlparse_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(XMLPARSE_KW));
-    custom_fn(p, XMLPARSE_KW, |p| {
-        if p.at(DOCUMENT_KW) || p.at(CONTENT_KW) {
-            p.bump_any();
-        } else {
-            p.error("expected DOCUMENT or CONTENT");
-        }
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        if p.eat(PRESERVE_KW) || p.eat(STRIP_KW) {
-            p.expect(WHITESPACE_KW);
-        }
-    })
+    let m = p.start();
+    p.expect(XMLPARSE_KW);
+    p.expect(L_PAREN);
+    if p.at(DOCUMENT_KW) || p.at(CONTENT_KW) {
+        p.bump_any();
+    } else {
+        p.error("expected DOCUMENT or CONTENT");
+    }
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    if p.eat(PRESERVE_KW) || p.eat(STRIP_KW) {
+        p.expect(WHITESPACE_KW);
+    }
+    p.expect(R_PAREN);
+    let m = m.complete(p, XML_PARSE_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 fn opt_xml_passing_mech(p: &mut Parser<'_>) -> bool {
+    let m = p.start();
     if p.eat(BY_KW) {
         if !p.eat(REF_KW) && !p.eat(VALUE_KW) {
             p.error("expected REF or VALUE");
         }
+        m.complete(p, XML_PASSING_MECH);
         true
     } else {
+        m.abandon(p);
         false
     }
 }
 
-fn xmlexists_arg(p: &mut Parser<'_>) {
-    p.expect(PASSING_KW);
-    opt_xml_passing_mech(p);
-    if expr(p).is_none() {
-        p.error("expected expression");
-    }
-    opt_xml_passing_mech(p);
-}
-
 // XMLEXISTS '(' c_expr xmlexists_argument ')'
 //   xmlexists_argument:
 //     | PASSING c_expr
@@ -920,12 +963,14 @@ fn xmlexists_arg(p: &mut Parser<'_>) {
 //       | BY VALUE_P
 fn xmlexists_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(XMLEXISTS_KW));
-    custom_fn(p, XMLEXISTS_KW, |p| {
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        xmlexists_arg(p);
-    })
+    let m = p.start();
+    p.expect(XMLEXISTS_KW);
+    p.expect(L_PAREN);
+    xml_row_passing_clause(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, XML_EXISTS_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ',' expr_list ')'
@@ -942,46 +987,60 @@ fn xmlexists_fn(p: &mut Parser<'_>) -> CompletedMarker {
 //      | a_expr
 fn xmlelement_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(XMLELEMENT_KW));
-    custom_fn(p, XMLELEMENT_KW, |p| {
-        p.expect(NAME_KW);
-        col_label(p);
-        if p.eat(COMMA) {
-            if p.eat(XMLATTRIBUTES_KW) {
-                // TODO: use delimited
-                p.expect(L_PAREN);
-                xml_attribute_list(p);
-                p.expect(R_PAREN);
-                if p.eat(COMMA) && !expr_list(p) {
-                    p.error("expected expression list");
-                }
-            } else if !expr_list(p) {
+    let m = p.start();
+    p.expect(XMLELEMENT_KW);
+    p.expect(L_PAREN);
+    p.expect(NAME_KW);
+    col_label(p);
+    if p.eat(COMMA) {
+        if p.eat(XMLATTRIBUTES_KW) {
+            // TODO: use delimited
+            p.expect(L_PAREN);
+            xml_attribute_list(p);
+            p.expect(R_PAREN);
+            if p.eat(COMMA) && !opt_expr_list(p) {
                 p.error("expected expression list");
             }
+        } else if !opt_expr_list(p) {
+            p.error("expected expression list");
         }
-    })
+    }
+    p.expect(R_PAREN);
+    let m = m.complete(p, XML_ELEMENT_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 fn xml_attribute_list(p: &mut Parser<'_>) {
+    let m = p.start();
     // TODO: use delimited
     while !p.at(EOF) && !p.at(R_PAREN) {
+        let m = p.start();
         if expr(p).is_none() {
             p.error("expected expression");
         }
         if p.eat(AS_KW) {
             col_label(p);
         }
+        m.complete(p, EXPR_AS_NAME);
         if !p.eat(COMMA) {
             break;
         }
     }
+    m.complete(p, XML_ATTRIBUTE_LIST);
 }
 
 // XMLFOREST '(' xml_attribute_list ')'
 fn xmlforest_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(XMLFOREST_KW));
-    custom_fn(p, XMLFOREST_KW, |p| {
-        xml_attribute_list(p);
-    })
+    let m = p.start();
+    p.expect(XMLFOREST_KW);
+    p.expect(L_PAREN);
+    xml_attribute_list(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, XML_FOREST_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // XMLSERIALIZE '(' document_or_content a_expr AS SimpleTypename xml_indent_option ')'
@@ -991,23 +1050,28 @@ fn xmlforest_fn(p: &mut Parser<'_>) -> CompletedMarker {
 //   | /*EMPTY*/
 fn xmlserialize_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(XMLSERIALIZE_KW));
-    custom_fn(p, XMLSERIALIZE_KW, |p| {
-        if p.at(DOCUMENT_KW) || p.at(CONTENT_KW) {
-            p.bump_any();
-        } else {
-            p.error("expected DOCUMENT or CONTENT");
-        }
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        p.expect(AS_KW);
-        type_name(p);
-        if p.eat(NO_KW) {
-            p.expect(INDENT_KW);
-        } else {
-            p.eat(INDENT_KW);
-        }
-    })
+    let m = p.start();
+    p.expect(XMLSERIALIZE_KW);
+    p.expect(L_PAREN);
+    if p.at(DOCUMENT_KW) || p.at(CONTENT_KW) {
+        p.bump_any();
+    } else {
+        p.error("expected DOCUMENT or CONTENT");
+    }
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    p.expect(AS_KW);
+    type_name(p);
+    if p.eat(NO_KW) {
+        p.expect(INDENT_KW);
+    } else {
+        p.eat(INDENT_KW);
+    }
+    p.expect(R_PAREN);
+    let m = m.complete(p, XML_SERIALIZE_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // XMLROOT '(' a_expr ',' xml_root_version opt_xml_root_standalone ')'
@@ -1021,39 +1085,60 @@ fn xmlserialize_fn(p: &mut Parser<'_>) -> CompletedMarker {
 //     | /*EMPTY*/
 fn xmlroot_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(XMLROOT_KW));
-    custom_fn(p, XMLROOT_KW, |p| {
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        p.expect(COMMA);
-        p.expect(VERSION_KW);
+    let m = p.start();
+    p.expect(XMLROOT_KW);
+    p.expect(L_PAREN);
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    p.expect(COMMA);
+    p.expect(VERSION_KW);
+    if p.eat(NO_KW) {
+        p.expect(VALUE_KW);
+    } else if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    if p.eat(COMMA) {
+        p.expect(STANDALONE_KW);
         if p.eat(NO_KW) {
-            p.expect(VALUE_KW);
-        } else if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        if p.eat(COMMA) {
-            p.expect(STANDALONE_KW);
-            if p.eat(NO_KW) {
-                p.eat(VALUE_KW);
-            } else {
-                p.expect(YES_KW);
-            }
+            p.eat(VALUE_KW);
+        } else {
+            p.expect(YES_KW);
         }
-    })
+    }
+    p.expect(R_PAREN);
+    let m = m.complete(p, XML_ROOT_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // JSON '(' json_value_expr json_key_uniqueness_constraint_opt ')'
 fn json_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(JSON_KW));
-    custom_fn(p, JSON_KW, |p| {
-        // json_value_expr
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        opt_json_format_clause(p);
-        opt_json_keys_unique_clause(p);
-    })
+    let m = p.start();
+    p.expect(JSON_KW);
+    p.expect(L_PAREN);
+    // json_value_expr
+    opt_expr(p);
+    opt_json_format_clause(p);
+    opt_json_keys_unique_clause(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, JSON_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
+}
+
+// JSON_SCALAR '(' json_value_expr_opt ')'
+fn json_scalar_fn(p: &mut Parser<'_>) -> CompletedMarker {
+    assert!(p.at(JSON_SCALAR_KW));
+    let m = p.start();
+    p.expect(JSON_SCALAR_KW);
+    p.expect(L_PAREN);
+    opt_expr(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, JSON_SCALAR_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // JSON_VALUE '('
@@ -1063,32 +1148,40 @@ fn json_fn(p: &mut Parser<'_>) -> CompletedMarker {
 // ')'
 fn json_value_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(JSON_VALUE_KW));
-    custom_fn(p, JSON_VALUE_KW, |p| {
-        // json_value_expr
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        opt_json_format_clause(p);
-        p.expect(COMMA);
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        opt_json_passing_clause(p);
-        opt_json_returning_clause(p);
-        opt_json_behavior_clause(p);
-    })
+    let m = p.start();
+    p.expect(JSON_VALUE_KW);
+    p.expect(L_PAREN);
+    // json_value_expr
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    opt_json_format_clause(p);
+    p.expect(COMMA);
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    opt_json_passing_clause(p);
+    opt_json_returning_clause(p);
+    opt_json_behavior_clause(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, JSON_VALUE_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // JSON_SERIALIZE '(' json_value_expr json_returning_clause_opt ')'
 fn json_serialize_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(JSON_SERIALIZE_KW));
-    custom_fn(p, JSON_SERIALIZE_KW, |p| {
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        opt_json_format_clause(p);
-        opt_json_returning_clause(p);
-    })
+    let m = p.start();
+    p.expect(JSON_SERIALIZE_KW);
+    p.expect(L_PAREN);
+    opt_expr(p);
+    opt_json_format_clause(p);
+    opt_json_returning_clause(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, JSON_SERIALIZE_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 // JSON_QUERY (
@@ -1102,23 +1195,28 @@ fn json_serialize_fn(p: &mut Parser<'_>) -> CompletedMarker {
 // )
 fn json_query_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(JSON_QUERY_KW));
-    custom_fn(p, JSON_QUERY_KW, |p| {
-        // context_item
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        opt_json_format_clause(p);
-        p.expect(COMMA);
-        // path_expression
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        opt_json_passing_clause(p);
-        opt_json_returning_clause(p);
-        opt_json_wrapper_behavior(p);
-        opt_json_quotes_clause(p);
-        opt_json_behavior_clause(p);
-    })
+    let m = p.start();
+    p.expect(JSON_QUERY_KW);
+    p.expect(L_PAREN);
+    // context_item
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    opt_json_format_clause(p);
+    p.expect(COMMA);
+    // path_expression
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    opt_json_passing_clause(p);
+    opt_json_returning_clause(p);
+    opt_json_wrapper_behavior(p);
+    opt_json_quotes_clause(p);
+    opt_json_behavior_clause(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, JSON_QUERY_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 fn opt_json_quotes_clause(p: &mut Parser<'_>) -> Option<CompletedMarker> {
@@ -1195,18 +1293,23 @@ fn opt_json_wrapper_behavior(p: &mut Parser<'_>) -> Option<CompletedMarker> {
 // )
 fn json_exists_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(JSON_EXISTS_KW));
-    custom_fn(p, JSON_EXISTS_KW, |p| {
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        opt_json_format_clause(p);
-        p.expect(COMMA);
-        if expr(p).is_none() {
-            p.error("expected expression");
-        }
-        opt_json_passing_clause(p);
-        opt_json_on_error_clause(p);
-    })
+    let m = p.start();
+    p.expect(JSON_EXISTS_KW);
+    p.expect(L_PAREN);
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    opt_json_format_clause(p);
+    p.expect(COMMA);
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    opt_json_passing_clause(p);
+    opt_json_on_error_clause(p);
+    p.expect(R_PAREN);
+    let m = m.complete(p, JSON_EXISTS_FN).precede(p);
+    opt_agg_clauses(p);
+    m.complete(p, CALL_EXPR)
 }
 
 fn opt_json_on_error_clause(p: &mut Parser<'_>) {
@@ -2260,7 +2363,7 @@ fn bexpr(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     )
 }
 
-fn json_object_arg(p: &mut Parser) -> Option<CompletedMarker> {
+fn json_key_value(p: &mut Parser) -> Option<CompletedMarker> {
     let m = p.start();
     if expr(p).is_none() {
         p.error("expected expression");
@@ -2482,7 +2585,7 @@ fn expr_bp(p: &mut Parser<'_>, bp: u8, r: &Restrictions) -> Option<CompletedMark
     Some(lhs)
 }
 
-fn expr_list(p: &mut Parser) -> bool {
+fn opt_expr_list(p: &mut Parser) -> bool {
     let mut found_expr = false;
     while !p.at(COMMA) {
         if expr(p).is_none() {
@@ -2744,7 +2847,7 @@ fn opt_locking_clause(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     }
     lock_strength(p);
     if p.eat(OF_KW) {
-        if !expr_list(p) {
+        if !opt_expr_list(p) {
             p.error("expected an expression");
         }
     }
@@ -3065,17 +3168,7 @@ fn from_item_name(p: &mut Parser<'_>) {
                 // we're at a table_name
                 p.eat(STAR);
                 opt_alias(p);
-                // [ TABLESAMPLE sampling_method ( argument [, ...] ) [ REPEATABLE ( seed ) ] ]
-                if p.eat(TABLESAMPLE_KW) {
-                    call_expr(p);
-                    if p.eat(REPEATABLE_KW) {
-                        p.eat(R_PAREN);
-                        if expr(p).is_none() {
-                            p.error("expected a seed");
-                        }
-                        p.eat(L_PAREN);
-                    }
-                }
+                opt_tablesample_clause(p);
             }
             got => {
                 p.error(format!("expected a name, got {got:?}"));
@@ -3098,20 +3191,7 @@ fn data_source(p: &mut Parser<'_>) {
             opt_alias(p);
         }
         XMLTABLE_KW => {
-            p.bump(XMLTABLE_KW);
-            p.expect(L_PAREN);
-            if p.eat(XMLNAMESPACES_KW) {
-                p.expect(L_PAREN);
-                xml_namespace_list(p);
-                p.expect(R_PAREN);
-                p.expect(COMMA);
-            }
-            if expr(p).is_none() {
-                p.error("expected expression");
-            }
-            xmlexists_arg(p);
-            xmltable_column_list(p);
-            p.expect(R_PAREN);
+            xml_table_fn(p);
             opt_alias(p);
         }
         ROWS_KW if p.nth_at(1, FROM_KW) => {
@@ -3146,6 +3226,34 @@ fn data_source(p: &mut Parser<'_>) {
     }
 }
 
+fn xml_table_fn(p: &mut Parser<'_>) {
+    assert!(p.at(XMLTABLE_KW));
+    p.bump(XMLTABLE_KW);
+    p.expect(L_PAREN);
+    if p.eat(XMLNAMESPACES_KW) {
+        xml_namespace_list(p);
+        p.expect(COMMA);
+    }
+    xml_row_passing_clause(p);
+    xmltable_column_list(p);
+    p.expect(R_PAREN);
+}
+
+fn xml_row_passing_clause(p: &mut Parser<'_>) {
+    let m = p.start();
+    // row_expression PASSING [BY {REF|VALUE}] document_expression [BY {REF|VALUE}]
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    p.expect(PASSING_KW);
+    opt_xml_passing_mech(p);
+    if expr(p).is_none() {
+        p.error("expected expression");
+    }
+    opt_xml_passing_mech(p);
+    m.complete(p, XML_ROW_PASSING_CLAUSE);
+}
+
 fn opt_row_from_expr(p: &mut Parser<'_>) -> bool {
     if !p.at_ts(EXPR_FIRST) {
         return false;
@@ -3212,13 +3320,26 @@ fn opt_xmltable_column_option_el(p: &mut Parser<'_>) -> Option<CompletedMarker>
 }
 
 fn xml_namespace_list(p: &mut Parser<'_>) {
-    xml_namespace_element(p);
-    while !p.at(EOF) && p.eat(COMMA) {
-        xml_namespace_element(p);
-    }
+    let m = p.start();
+    delimited(
+        p,
+        L_PAREN,
+        R_PAREN,
+        COMMA,
+        || "unexpected comma".to_string(),
+        XML_NAMESPACE_ELEMENT_FIRST,
+        opt_xml_namespace,
+    );
+    m.complete(p, XML_NAMESPACE_LIST);
 }
 
-fn xml_namespace_element(p: &mut Parser<'_>) {
+const XML_NAMESPACE_ELEMENT_FIRST: TokenSet = EXPR_FIRST.union(TokenSet::new(&[DEFAULT_KW]));
+
+fn opt_xml_namespace(p: &mut Parser<'_>) -> bool {
+    if !p.at_ts(XML_NAMESPACE_ELEMENT_FIRST) {
+        return false;
+    }
+    let m = p.start();
     if p.eat(DEFAULT_KW) {
         if expr(p).is_none() {
             p.error("expected expression");
@@ -3230,6 +3351,8 @@ fn xml_namespace_element(p: &mut Parser<'_>) {
         p.expect(AS_KW);
         col_label(p);
     }
+    m.complete(p, XML_NAMESPACE);
+    true
 }
 
 fn paren_data_source(p: &mut Parser<'_>) -> Option<CompletedMarker> {
@@ -4118,7 +4241,7 @@ fn opt_constraint_where_clause(p: &mut Parser<'_>) {
             p.error("expected expr");
         }
         p.expect(R_PAREN);
-        m.complete(p, CONSTRAINT_WHERE_CLAUSE);
+        m.complete(p, WHERE_CONDITION_CLAUSE);
     }
 }
 
@@ -4384,6 +4507,33 @@ fn opt_alias(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     Some(m.complete(p, ALIAS))
 }
 
+// [ TABLESAMPLE sampling_method ( argument [, ...] ) [ REPEATABLE ( seed ) ] ]
+fn opt_tablesample_clause(p: &mut Parser<'_>) -> Option<CompletedMarker> {
+    if !p.at(TABLESAMPLE_KW) {
+        return None;
+    }
+    let m = p.start();
+    p.bump(TABLESAMPLE_KW);
+    call_expr(p);
+    opt_repeatable_clause(p);
+    Some(m.complete(p, TABLESAMPLE_CLAUSE))
+}
+
+// [ REPEATABLE ( seed ) ]
+fn opt_repeatable_clause(p: &mut Parser<'_>) -> Option<CompletedMarker> {
+    if !p.at(REPEATABLE_KW) {
+        return None;
+    }
+    let m = p.start();
+    p.bump(REPEATABLE_KW);
+    p.expect(L_PAREN);
+    if expr(p).is_none() {
+        p.error("expected a seed");
+    }
+    p.expect(R_PAREN);
+    Some(m.complete(p, REPEATABLE_CLAUSE))
+}
+
 fn opt_where_clause(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     if !p.at(WHERE_KW) {
         return None;
@@ -4555,7 +4705,7 @@ fn window_spec(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     opt_ident(p);
     if p.eat(PARTITION_KW) {
         p.expect(BY_KW);
-        if !expr_list(p) {
+        if !opt_expr_list(p) {
             p.error("expected expression")
         }
     }
@@ -8986,21 +9136,16 @@ fn create_procedure(p: &mut Parser<'_>) -> CompletedMarker {
 // TABLES IN SCHEMA { schema_name | CURRENT_SCHEMA } [ WHERE ( expression ) ]
 // CURRENT_SCHEMA
 fn publication_object(p: &mut Parser<'_>) {
+    let m = p.start();
     if p.eat(TABLES_KW) {
         p.expect(IN_KW);
         p.expect(SCHEMA_KW);
         if !p.eat(CURRENT_SCHEMA_KW) {
             name_ref(p);
         }
-        if p.eat(WHERE_KW) {
-            p.expect(L_PAREN);
-            if expr(p).is_none() {
-                p.error("expected expression");
-            }
-            p.expect(R_PAREN);
-        }
+        opt_constraint_where_clause(p);
     } else if p.eat(CURRENT_SCHEMA_KW) {
-        return;
+        // pass
     } else {
         p.eat(TABLE_KW);
         p.eat(ONLY_KW);
@@ -9012,14 +9157,9 @@ fn publication_object(p: &mut Parser<'_>) {
         }
         p.eat(STAR);
         opt_column_list(p);
-        if p.eat(WHERE_KW) {
-            p.expect(L_PAREN);
-            if expr(p).is_none() {
-                p.error("expected expression");
-            }
-            p.expect(R_PAREN);
-        }
+        opt_constraint_where_clause(p);
     }
+    m.complete(p, PUBLICATION_OBJECT);
 }
 
 // CREATE PUBLICATION name
@@ -9203,7 +9343,7 @@ fn create_statistics(p: &mut Parser<'_>) -> CompletedMarker {
     }
     opt_paren_name_ref_list(p);
     if p.eat(ON_KW) {
-        if !expr_list(p) {
+        if !opt_expr_list(p) {
             p.error("expected expression")
         }
     }
diff --git a/crates/squawk_parser/tests/data/ok/select.sql b/crates/squawk_parser/tests/data/ok/select.sql
index 4805dddb..72fa0f6f 100644
--- a/crates/squawk_parser/tests/data/ok/select.sql
+++ b/crates/squawk_parser/tests/data/ok/select.sql
@@ -75,6 +75,11 @@ select 1 > some(select 1);
 -- all
 select 1 = all(select 1);
 
+-- some/all/any with expr
+select 1 = all(array[1]);
+select 1 = some(array[1]);
+select 1 = any(array[1]);
+
 -- all with array
 select * from t
 where not (tag = all(array['a', 'b', 'c']));
diff --git a/crates/squawk_parser/tests/data/ok/select_xml.sql b/crates/squawk_parser/tests/data/ok/select_xml.sql
new file mode 100644
index 00000000..f47d8143
--- /dev/null
+++ b/crates/squawk_parser/tests/data/ok/select_xml.sql
@@ -0,0 +1,34 @@
+-- xmltable
+select *
+from xmltable(
+    xmlnamespaces('http://example.com/books' as bk),
+    '/bk:library/bk:book'
+    passing xmlparse(document '<library xmlns="http://example.com/books">
+               <book id="1">
+                 <title>the great gatsby</title>
+                 <author>f. scott fitzgerald</author>
+                 <year>1925</year>
+                 <price>12.99</price>
+               </book>
+               <book id="2">
+                 <title>1984</title>
+                 <author>george orwell</author>
+                 <year>1949</year>
+                 <price>14.99</price>
+               </book>
+               <book id="3">
+                 <title>to kill a mockingbird</title>
+                 <author>harper lee</author>
+                 <year>1960</year>
+                 <price>13.99</price>
+               </book>
+             </library>')
+    columns
+        row_num for ordinality,
+        book_id integer path '@id',
+        title text path 'bk:title',
+        author text path 'bk:author',
+        year integer path 'bk:year',
+        price numeric(5,2) path 'bk:price' default 0.00,
+        discount numeric(5,2) default 0.00 null
+);
diff --git a/crates/squawk_parser/tests/snapshots/tests__alter_publication_ok.snap b/crates/squawk_parser/tests/snapshots/tests__alter_publication_ok.snap
index 96d8e4e0..1a70c6c5 100644
--- a/crates/squawk_parser/tests/snapshots/tests__alter_publication_ok.snap
+++ b/crates/squawk_parser/tests/snapshots/tests__alter_publication_ok.snap
@@ -15,12 +15,13 @@ SOURCE_FILE
     WHITESPACE " "
     ADD_KW "add"
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t"
   SEMICOLON ";"
   WHITESPACE "\n"
   ALTER_PUBLICATION
@@ -33,63 +34,68 @@ SOURCE_FILE
     WHITESPACE " "
     ADD_KW "add"
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t1"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t1"
     COMMA ","
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t2"
-    WHITESPACE " "
-    WHERE_KW "where"
-    WHITESPACE " "
-    L_PAREN "("
-    BIN_EXPR
-      NAME_REF
-        IDENT "a"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
       WHITESPACE " "
-      R_ANGLE ">"
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t2"
       WHITESPACE " "
-      NAME_REF
-        IDENT "b"
-    R_PAREN ")"
+      WHERE_CONDITION_CLAUSE
+        WHERE_KW "where"
+        WHITESPACE " "
+        L_PAREN "("
+        BIN_EXPR
+          NAME_REF
+            IDENT "a"
+          WHITESPACE " "
+          R_ANGLE ">"
+          WHITESPACE " "
+          NAME_REF
+            IDENT "b"
+        R_PAREN ")"
     COMMA ","
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    ONLY_KW "only"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      ONLY_KW "only"
+      WHITESPACE " "
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t"
     COMMA ","
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t"
-    WHITESPACE " "
-    COLUMN_LIST
-      L_PAREN "("
-      COLUMN
-        NAME_REF
-          IDENT "a"
-      COMMA ","
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
       WHITESPACE " "
-      COLUMN
-        NAME_REF
-          IDENT "b"
-      R_PAREN ")"
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t"
+      WHITESPACE " "
+      COLUMN_LIST
+        L_PAREN "("
+        COLUMN
+          NAME_REF
+            IDENT "a"
+        COMMA ","
+        WHITESPACE " "
+        COLUMN
+          NAME_REF
+            IDENT "b"
+        R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- add_tables_in_schema"
@@ -104,14 +110,15 @@ SOURCE_FILE
     WHITESPACE " "
     ADD_KW "add"
     WHITESPACE " "
-    TABLES_KW "tables"
-    WHITESPACE " "
-    IN_KW "in"
-    WHITESPACE " "
-    SCHEMA_KW "schema"
-    WHITESPACE " "
-    NAME_REF
-      IDENT "s"
+    PUBLICATION_OBJECT
+      TABLES_KW "tables"
+      WHITESPACE " "
+      IN_KW "in"
+      WHITESPACE " "
+      SCHEMA_KW "schema"
+      WHITESPACE " "
+      NAME_REF
+        IDENT "s"
   SEMICOLON ";"
   WHITESPACE "\n"
   ALTER_PUBLICATION
@@ -124,13 +131,14 @@ SOURCE_FILE
     WHITESPACE " "
     ADD_KW "add"
     WHITESPACE " "
-    TABLES_KW "tables"
-    WHITESPACE " "
-    IN_KW "in"
-    WHITESPACE " "
-    SCHEMA_KW "schema"
-    WHITESPACE " "
-    CURRENT_SCHEMA_KW "current_schema"
+    PUBLICATION_OBJECT
+      TABLES_KW "tables"
+      WHITESPACE " "
+      IN_KW "in"
+      WHITESPACE " "
+      SCHEMA_KW "schema"
+      WHITESPACE " "
+      CURRENT_SCHEMA_KW "current_schema"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- set_table"
@@ -145,12 +153,13 @@ SOURCE_FILE
     WHITESPACE " "
     SET_KW "set"
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t"
   SEMICOLON ";"
   WHITESPACE "\n"
   ALTER_PUBLICATION
@@ -163,63 +172,68 @@ SOURCE_FILE
     WHITESPACE " "
     SET_KW "set"
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t1"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t1"
     COMMA ","
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t2"
-    WHITESPACE " "
-    WHERE_KW "where"
-    WHITESPACE " "
-    L_PAREN "("
-    BIN_EXPR
-      NAME_REF
-        IDENT "a"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
       WHITESPACE " "
-      R_ANGLE ">"
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t2"
       WHITESPACE " "
-      NAME_REF
-        IDENT "b"
-    R_PAREN ")"
+      WHERE_CONDITION_CLAUSE
+        WHERE_KW "where"
+        WHITESPACE " "
+        L_PAREN "("
+        BIN_EXPR
+          NAME_REF
+            IDENT "a"
+          WHITESPACE " "
+          R_ANGLE ">"
+          WHITESPACE " "
+          NAME_REF
+            IDENT "b"
+        R_PAREN ")"
     COMMA ","
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    ONLY_KW "only"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      ONLY_KW "only"
+      WHITESPACE " "
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t"
     COMMA ","
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t"
-    WHITESPACE " "
-    COLUMN_LIST
-      L_PAREN "("
-      COLUMN
-        NAME_REF
-          IDENT "a"
-      COMMA ","
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
       WHITESPACE " "
-      COLUMN
-        NAME_REF
-          IDENT "b"
-      R_PAREN ")"
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t"
+      WHITESPACE " "
+      COLUMN_LIST
+        L_PAREN "("
+        COLUMN
+          NAME_REF
+            IDENT "a"
+        COMMA ","
+        WHITESPACE " "
+        COLUMN
+          NAME_REF
+            IDENT "b"
+        R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- set_parameters"
@@ -269,12 +283,13 @@ SOURCE_FILE
     WHITESPACE " "
     DROP_KW "drop"
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t"
   SEMICOLON ";"
   WHITESPACE "\n"
   ALTER_PUBLICATION
@@ -287,63 +302,68 @@ SOURCE_FILE
     WHITESPACE " "
     DROP_KW "drop"
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t1"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t1"
     COMMA ","
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t2"
-    WHITESPACE " "
-    WHERE_KW "where"
-    WHITESPACE " "
-    L_PAREN "("
-    BIN_EXPR
-      NAME_REF
-        IDENT "a"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
       WHITESPACE " "
-      R_ANGLE ">"
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t2"
       WHITESPACE " "
-      NAME_REF
-        IDENT "b"
-    R_PAREN ")"
+      WHERE_CONDITION_CLAUSE
+        WHERE_KW "where"
+        WHITESPACE " "
+        L_PAREN "("
+        BIN_EXPR
+          NAME_REF
+            IDENT "a"
+          WHITESPACE " "
+          R_ANGLE ">"
+          WHITESPACE " "
+          NAME_REF
+            IDENT "b"
+        R_PAREN ")"
     COMMA ","
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    ONLY_KW "only"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      ONLY_KW "only"
+      WHITESPACE " "
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t"
     COMMA ","
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "t"
-    WHITESPACE " "
-    COLUMN_LIST
-      L_PAREN "("
-      COLUMN
-        NAME_REF
-          IDENT "a"
-      COMMA ","
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
       WHITESPACE " "
-      COLUMN
-        NAME_REF
-          IDENT "b"
-      R_PAREN ")"
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "t"
+      WHITESPACE " "
+      COLUMN_LIST
+        L_PAREN "("
+        COLUMN
+          NAME_REF
+            IDENT "a"
+        COMMA ","
+        WHITESPACE " "
+        COLUMN
+          NAME_REF
+            IDENT "b"
+        R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- owner_to"
diff --git a/crates/squawk_parser/tests/snapshots/tests__alter_table_ok.snap b/crates/squawk_parser/tests/snapshots/tests__alter_table_ok.snap
index 4de6e680..ec2bf97b 100644
--- a/crates/squawk_parser/tests/snapshots/tests__alter_table_ok.snap
+++ b/crates/squawk_parser/tests/snapshots/tests__alter_table_ok.snap
@@ -2544,7 +2544,7 @@ SOURCE_FILE
           WHITESPACE "\n"
           R_PAREN ")"
         WHITESPACE " "
-        CONSTRAINT_WHERE_CLAUSE
+        WHERE_CONDITION_CLAUSE
           WHERE_KW "WHERE"
           WHITESPACE " "
           L_PAREN "("
diff --git a/crates/squawk_parser/tests/snapshots/tests__create_publication_ok.snap b/crates/squawk_parser/tests/snapshots/tests__create_publication_ok.snap
index 4b0058ee..dceb5dfd 100644
--- a/crates/squawk_parser/tests/snapshots/tests__create_publication_ok.snap
+++ b/crates/squawk_parser/tests/snapshots/tests__create_publication_ok.snap
@@ -67,108 +67,114 @@ SOURCE_FILE
     WHITESPACE " "
     FOR_KW "for"
     WHITESPACE " \n  "
-    TABLE_KW "table"
-    WHITESPACE " "
-    ONLY_KW "only"
-    WHITESPACE " "
-    PATH
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      ONLY_KW "only"
+      WHITESPACE " "
       PATH
+        PATH
+          PATH_SEGMENT
+            NAME_REF
+              IDENT "foo"
+        DOT "."
         PATH_SEGMENT
           NAME_REF
-            IDENT "foo"
-      DOT "."
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "bar"
+            IDENT "bar"
     COMMA ","
     WHITESPACE " \n  "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
       PATH
         PATH
+          PATH
+            PATH_SEGMENT
+              NAME_REF
+                IDENT "foo"
+          DOT "."
           PATH_SEGMENT
             NAME_REF
-              IDENT "foo"
+              IDENT "bar"
         DOT "."
         PATH_SEGMENT
           NAME_REF
-            IDENT "bar"
-      DOT "."
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "buzz"
-    WHITESPACE " "
-    STAR "*"
+            IDENT "buzz"
+      WHITESPACE " "
+      STAR "*"
     COMMA ","
     WHITESPACE " \n  "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "foo"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "foo"
     COMMA ","
     WHITESPACE " \n  "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "foo"
-    COLUMN_LIST
-      L_PAREN "("
-      COLUMN
-        NAME_REF
-          IDENT "a"
-      COMMA ","
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
       WHITESPACE " "
-      COLUMN
-        NAME_REF
-          IDENT "b"
-      COMMA ","
-      WHITESPACE " "
-      COLUMN
-        NAME_REF
-          IDENT "c"
-      R_PAREN ")"
-    WHITESPACE " "
-    WHERE_KW "where"
-    WHITESPACE " "
-    L_PAREN "("
-    BIN_EXPR
-      BIN_EXPR
-        NAME_REF
-          IDENT "x"
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "foo"
+      COLUMN_LIST
+        L_PAREN "("
+        COLUMN
+          NAME_REF
+            IDENT "a"
+        COMMA ","
         WHITESPACE " "
-        R_ANGLE ">"
+        COLUMN
+          NAME_REF
+            IDENT "b"
+        COMMA ","
         WHITESPACE " "
-        LITERAL
-          INT_NUMBER "10"
-      WHITESPACE " "
-      OR_KW "or"
+        COLUMN
+          NAME_REF
+            IDENT "c"
+        R_PAREN ")"
       WHITESPACE " "
-      BIN_EXPR
-        NAME_REF
-          IDENT "a"
-        WHITESPACE " "
-        NEQ "!="
+      WHERE_CONDITION_CLAUSE
+        WHERE_KW "where"
         WHITESPACE " "
-        NAME_REF
-          IDENT "b"
-    R_PAREN ")"
+        L_PAREN "("
+        BIN_EXPR
+          BIN_EXPR
+            NAME_REF
+              IDENT "x"
+            WHITESPACE " "
+            R_ANGLE ">"
+            WHITESPACE " "
+            LITERAL
+              INT_NUMBER "10"
+          WHITESPACE " "
+          OR_KW "or"
+          WHITESPACE " "
+          BIN_EXPR
+            NAME_REF
+              IDENT "a"
+            WHITESPACE " "
+            NEQ "!="
+            WHITESPACE " "
+            NAME_REF
+              IDENT "b"
+        R_PAREN ")"
     COMMA ","
     WHITESPACE "\n  "
-    TABLE_KW "table"
-    WHITESPACE " "
-    ONLY_KW "only"
-    WHITESPACE " "
-    L_PAREN "("
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "foo"
-    R_PAREN ")"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      ONLY_KW "only"
+      WHITESPACE " "
+      L_PAREN "("
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "foo"
+      R_PAREN ")"
     WHITESPACE "\n  "
     WITH_PARAMS
       WITH_KW "with"
@@ -207,29 +213,33 @@ SOURCE_FILE
     WHITESPACE "\n  "
     FOR_KW "for"
     WHITESPACE " "
-    TABLES_KW "tables"
-    WHITESPACE " "
-    IN_KW "in"
-    WHITESPACE " "
-    SCHEMA_KW "schema"
-    WHITESPACE " "
-    NAME_REF
-      IDENT "a"
+    PUBLICATION_OBJECT
+      TABLES_KW "tables"
+      WHITESPACE " "
+      IN_KW "in"
+      WHITESPACE " "
+      SCHEMA_KW "schema"
+      WHITESPACE " "
+      NAME_REF
+        IDENT "a"
     COMMA ","
     WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "b"
+    PUBLICATION_OBJECT
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "b"
     COMMA ","
     WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "c"
+    PUBLICATION_OBJECT
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "c"
     COMMA ","
     WHITESPACE " "
-    CURRENT_SCHEMA_KW "current_schema"
+    PUBLICATION_OBJECT
+      CURRENT_SCHEMA_KW "current_schema"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- multiple tables"
@@ -244,17 +254,19 @@ SOURCE_FILE
     WHITESPACE " "
     FOR_KW "for"
     WHITESPACE " "
-    TABLE_KW "table"
-    WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "chats"
+    PUBLICATION_OBJECT
+      TABLE_KW "table"
+      WHITESPACE " "
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "chats"
     COMMA ","
     WHITESPACE " "
-    PATH
-      PATH_SEGMENT
-        NAME_REF
-          IDENT "users"
+    PUBLICATION_OBJECT
+      PATH
+        PATH_SEGMENT
+          NAME_REF
+            IDENT "users"
   SEMICOLON ";"
   WHITESPACE "\n"
diff --git a/crates/squawk_parser/tests/snapshots/tests__create_table_ok.snap b/crates/squawk_parser/tests/snapshots/tests__create_table_ok.snap
index c9c6c9e8..ec3cdf14 100644
--- a/crates/squawk_parser/tests/snapshots/tests__create_table_ok.snap
+++ b/crates/squawk_parser/tests/snapshots/tests__create_table_ok.snap
@@ -477,9 +477,8 @@ SOURCE_FILE
         WHITESPACE "\n  "
         PARTITION_ITEM
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               MONTH_KW "month"
               WHITESPACE " "
@@ -2004,7 +2003,7 @@ SOURCE_FILE
           WHITESPACE " "
           R_PAREN ")"
         WHITESPACE " "
-        CONSTRAINT_WHERE_CLAUSE
+        WHERE_CONDITION_CLAUSE
           WHERE_KW "where"
           WHITESPACE " "
           L_PAREN "("
@@ -2100,7 +2099,7 @@ SOURCE_FILE
           WHITESPACE " "
           R_PAREN ")"
         WHITESPACE " \n    "
-        CONSTRAINT_WHERE_CLAUSE
+        WHERE_CONDITION_CLAUSE
           WHERE_KW "where"
           WHITESPACE " "
           L_PAREN "("
@@ -2237,7 +2236,7 @@ SOURCE_FILE
           NAME_REF
             IDENT "foo"
         WHITESPACE "\n    "
-        CONSTRAINT_WHERE_CLAUSE
+        WHERE_CONDITION_CLAUSE
           WHERE_KW "where"
           WHITESPACE " "
           L_PAREN "("
@@ -2532,7 +2531,7 @@ SOURCE_FILE
           WHITESPACE " "
           R_PAREN ")"
         WHITESPACE " "
-        CONSTRAINT_WHERE_CLAUSE
+        WHERE_CONDITION_CLAUSE
           WHERE_KW "where"
           WHITESPACE " "
           L_PAREN "("
diff --git a/crates/squawk_parser/tests/snapshots/tests__misc_ok.snap b/crates/squawk_parser/tests/snapshots/tests__misc_ok.snap
index a562248c..3f22c54d 100644
--- a/crates/squawk_parser/tests/snapshots/tests__misc_ok.snap
+++ b/crates/squawk_parser/tests/snapshots/tests__misc_ok.snap
@@ -1010,9 +1010,8 @@ SOURCE_FILE
               WHITESPACE " "
               CAST_EXPR
                 CALL_EXPR
-                  NAME_REF
+                  EXTRACT_FN
                     EXTRACT_KW "EXTRACT"
-                  ARG_LIST
                     L_PAREN "("
                     WHITESPACE " "
                     STRING "'hour'"
@@ -1069,9 +1068,8 @@ SOURCE_FILE
               WHITESPACE " "
               CAST_EXPR
                 CALL_EXPR
-                  NAME_REF
+                  EXTRACT_FN
                     EXTRACT_KW "EXTRACT"
-                  ARG_LIST
                     L_PAREN "("
                     WHITESPACE " "
                     STRING "'hour'"
diff --git a/crates/squawk_parser/tests/snapshots/tests__select_funcs_ok.snap b/crates/squawk_parser/tests/snapshots/tests__select_funcs_ok.snap
index 56660d20..3c6d7a09 100644
--- a/crates/squawk_parser/tests/snapshots/tests__select_funcs_ok.snap
+++ b/crates/squawk_parser/tests/snapshots/tests__select_funcs_ok.snap
@@ -324,9 +324,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            OVERLAY_FN
               OVERLAY_KW "overlay"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -355,9 +354,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            OVERLAY_FN
               OVERLAY_KW "overlay"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -381,9 +379,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            OVERLAY_FN
               OVERLAY_KW "overlay"
-            ARG_LIST
               L_PAREN "("
               R_PAREN ")"
   SEMICOLON ";"
@@ -395,9 +392,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            OVERLAY_FN
               OVERLAY_KW "overlay"
-            ARG_LIST
               L_PAREN "("
               LITERAL
                 INT_NUMBER "1"
@@ -431,9 +427,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            POSITION_FN
               POSITION_KW "position"
-            ARG_LIST
               L_PAREN "("
               LITERAL
                 STRING "'foo'"
@@ -452,9 +447,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            POSITION_FN
               POSITION_KW "position"
-            ARG_LIST
               L_PAREN "("
               BIN_EXPR
                 LITERAL
@@ -489,9 +483,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            POSITION_FN
               POSITION_KW "position"
-            ARG_LIST
               L_PAREN "("
               LITERAL
                 STRING "'c'"
@@ -512,9 +505,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            TRIM_FN
               TRIM_KW "trim"
-            ARG_LIST
               L_PAREN "("
               BOTH_KW "both"
               WHITESPACE " "
@@ -535,9 +527,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            TRIM_FN
               TRIM_KW "trim"
-            ARG_LIST
               L_PAREN "("
               BOTH_KW "both"
               WHITESPACE " "
@@ -555,9 +546,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            TRIM_FN
               TRIM_KW "trim"
-            ARG_LIST
               L_PAREN "("
               BOTH_KW "both"
               WHITESPACE " "
@@ -573,9 +563,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            TRIM_FN
               TRIM_KW "trim"
-            ARG_LIST
               L_PAREN "("
               LEADING_KW "leading"
               WHITESPACE " "
@@ -591,9 +580,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            TRIM_FN
               TRIM_KW "trim"
-            ARG_LIST
               L_PAREN "("
               TRAILING_KW "trailing"
               WHITESPACE " "
@@ -609,9 +597,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            TRIM_FN
               TRIM_KW "trim"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -627,9 +614,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            SUBSTRING_FN
               SUBSTRING_KW "substring"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -653,9 +639,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            SUBSTRING_FN
               SUBSTRING_KW "substring"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -679,9 +664,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            SUBSTRING_FN
               SUBSTRING_KW "substring"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -700,9 +684,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            SUBSTRING_FN
               SUBSTRING_KW "substring"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -721,9 +704,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            SUBSTRING_FN
               SUBSTRING_KW "substring"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -748,9 +730,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            SUBSTRING_FN
               SUBSTRING_KW "substring"
-            ARG_LIST
               L_PAREN "("
               BIN_EXPR
                 NAME_REF
@@ -792,9 +773,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            SUBSTRING_FN
               SUBSTRING_KW "substring"
-            ARG_LIST
               L_PAREN "("
               LITERAL
                 STRING "'hello world'"
@@ -840,9 +820,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_ELEMENT_FN
               XMLELEMENT_KW "xmlelement"
-            ARG_LIST
               L_PAREN "("
               NAME_KW "name"
               WHITESPACE " "
@@ -858,9 +837,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_ELEMENT_FN
               XMLELEMENT_KW "xmlelement"
-            ARG_LIST
               L_PAREN "("
               NAME_KW "name"
               WHITESPACE " "
@@ -870,17 +848,20 @@ SOURCE_FILE
               WHITESPACE " "
               XMLATTRIBUTES_KW "xmlattributes"
               L_PAREN "("
-              NAME_REF
-                IDENT "foo"
-              COMMA ","
-              WHITESPACE " "
-              NAME_REF
-                IDENT "bar"
-              WHITESPACE " "
-              AS_KW "as"
-              WHITESPACE " "
-              NAME
-                IDENT "b"
+              XML_ATTRIBUTE_LIST
+                EXPR_AS_NAME
+                  NAME_REF
+                    IDENT "foo"
+                COMMA ","
+                WHITESPACE " "
+                EXPR_AS_NAME
+                  NAME_REF
+                    IDENT "bar"
+                  WHITESPACE " "
+                  AS_KW "as"
+                  WHITESPACE " "
+                  NAME
+                    IDENT "b"
               R_PAREN ")"
               R_PAREN ")"
   SEMICOLON ";"
@@ -892,9 +873,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_ELEMENT_FN
               XMLELEMENT_KW "xmlelement"
-            ARG_LIST
               L_PAREN "("
               NAME_KW "name"
               WHITESPACE " "
@@ -922,9 +902,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_ELEMENT_FN
               XMLELEMENT_KW "xmlelement"
-            ARG_LIST
               L_PAREN "("
               NAME_KW "name"
               WHITESPACE " "
@@ -934,17 +913,20 @@ SOURCE_FILE
               WHITESPACE " "
               XMLATTRIBUTES_KW "xmlattributes"
               L_PAREN "("
-              NAME_REF
-                IDENT "buzz"
-              COMMA ","
-              WHITESPACE " "
-              NAME_REF
-                IDENT "foo"
-              WHITESPACE " "
-              AS_KW "as"
-              WHITESPACE " "
-              NAME
-                IDENT "c"
+              XML_ATTRIBUTE_LIST
+                EXPR_AS_NAME
+                  NAME_REF
+                    IDENT "buzz"
+                COMMA ","
+                WHITESPACE " "
+                EXPR_AS_NAME
+                  NAME_REF
+                    IDENT "foo"
+                  WHITESPACE " "
+                  AS_KW "as"
+                  WHITESPACE " "
+                  NAME
+                    IDENT "c"
               R_PAREN ")"
               COMMA ","
               WHITESPACE " "
@@ -966,17 +948,17 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_EXISTS_FN
               XMLEXISTS_KW "xmlexists"
-            ARG_LIST
               L_PAREN "("
-              LITERAL
-                STRING "'foo'"
-              WHITESPACE " "
-              PASSING_KW "passing"
-              WHITESPACE " "
-              LITERAL
-                STRING "'bar'"
+              XML_ROW_PASSING_CLAUSE
+                LITERAL
+                  STRING "'foo'"
+                WHITESPACE " "
+                PASSING_KW "passing"
+                WHITESPACE " "
+                LITERAL
+                  STRING "'bar'"
               R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n"
@@ -987,21 +969,22 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_EXISTS_FN
               XMLEXISTS_KW "xmlexists"
-            ARG_LIST
               L_PAREN "("
-              LITERAL
-                STRING "'foo'"
-              WHITESPACE " "
-              PASSING_KW "passing"
-              WHITESPACE " "
-              NAME_REF
-                IDENT "bar"
-              WHITESPACE " "
-              BY_KW "by"
-              WHITESPACE " "
-              REF_KW "ref"
+              XML_ROW_PASSING_CLAUSE
+                LITERAL
+                  STRING "'foo'"
+                WHITESPACE " "
+                PASSING_KW "passing"
+                WHITESPACE " "
+                NAME_REF
+                  IDENT "bar"
+                WHITESPACE " "
+                XML_PASSING_MECH
+                  BY_KW "by"
+                  WHITESPACE " "
+                  REF_KW "ref"
               R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n"
@@ -1012,21 +995,22 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_EXISTS_FN
               XMLEXISTS_KW "xmlexists"
-            ARG_LIST
               L_PAREN "("
-              LITERAL
-                STRING "'foo'"
-              WHITESPACE " "
-              PASSING_KW "passing"
-              WHITESPACE " "
-              BY_KW "by"
-              WHITESPACE " "
-              REF_KW "ref"
-              WHITESPACE " "
-              NAME_REF
-                IDENT "bar"
+              XML_ROW_PASSING_CLAUSE
+                LITERAL
+                  STRING "'foo'"
+                WHITESPACE " "
+                PASSING_KW "passing"
+                WHITESPACE " "
+                XML_PASSING_MECH
+                  BY_KW "by"
+                  WHITESPACE " "
+                  REF_KW "ref"
+                WHITESPACE " "
+                NAME_REF
+                  IDENT "bar"
               R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n"
@@ -1037,25 +1021,27 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_EXISTS_FN
               XMLEXISTS_KW "xmlexists"
-            ARG_LIST
               L_PAREN "("
-              LITERAL
-                STRING "'foo'"
-              WHITESPACE " "
-              PASSING_KW "passing"
-              WHITESPACE " "
-              BY_KW "by"
-              WHITESPACE " "
-              REF_KW "ref"
-              WHITESPACE " "
-              NAME_REF
-                IDENT "foo"
-              WHITESPACE " "
-              BY_KW "by"
-              WHITESPACE " "
-              VALUE_KW "value"
+              XML_ROW_PASSING_CLAUSE
+                LITERAL
+                  STRING "'foo'"
+                WHITESPACE " "
+                PASSING_KW "passing"
+                WHITESPACE " "
+                XML_PASSING_MECH
+                  BY_KW "by"
+                  WHITESPACE " "
+                  REF_KW "ref"
+                WHITESPACE " "
+                NAME_REF
+                  IDENT "foo"
+                WHITESPACE " "
+                XML_PASSING_MECH
+                  BY_KW "by"
+                  WHITESPACE " "
+                  VALUE_KW "value"
               R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
@@ -1068,20 +1054,23 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_FOREST_FN
               XMLFOREST_KW "xmlforest"
-            ARG_LIST
               L_PAREN "("
-              NAME_REF
-                IDENT "foo"
-              COMMA ","
-              WHITESPACE " "
-              NAME_REF
-                IDENT "bar"
-              COMMA ","
-              WHITESPACE " "
-              NAME_REF
-                IDENT "buzz"
+              XML_ATTRIBUTE_LIST
+                EXPR_AS_NAME
+                  NAME_REF
+                    IDENT "foo"
+                COMMA ","
+                WHITESPACE " "
+                EXPR_AS_NAME
+                  NAME_REF
+                    IDENT "bar"
+                COMMA ","
+                WHITESPACE " "
+                EXPR_AS_NAME
+                  NAME_REF
+                    IDENT "buzz"
               R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
@@ -1094,9 +1083,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_PARSE_FN
               XMLPARSE_KW "xmlparse"
-            ARG_LIST
               L_PAREN "("
               DOCUMENT_KW "document"
               WHITESPACE " "
@@ -1116,9 +1104,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_PARSE_FN
               XMLPARSE_KW "xmlparse"
-            ARG_LIST
               L_PAREN "("
               CONTENT_KW "content"
               WHITESPACE " "
@@ -1140,9 +1127,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_PI_FN
               XMLPI_KW "xmlpi"
-            ARG_LIST
               L_PAREN "("
               NAME_KW "name"
               WHITESPACE " "
@@ -1158,9 +1144,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_PI_FN
               XMLPI_KW "xmlpi"
-            ARG_LIST
               L_PAREN "("
               NAME_KW "name"
               WHITESPACE " "
@@ -1182,9 +1167,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_ROOT_FN
               XMLROOT_KW "xmlroot"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -1204,9 +1188,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_ROOT_FN
               XMLROOT_KW "xmlroot"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -1227,9 +1210,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_ROOT_FN
               XMLROOT_KW "xmlroot"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -1254,9 +1236,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_ROOT_FN
               XMLROOT_KW "xmlroot"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -1281,9 +1262,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_ROOT_FN
               XMLROOT_KW "xmlroot"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -1312,9 +1292,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_SERIALIZE_FN
               XMLSERIALIZE_KW "xmlserialize"
-            ARG_LIST
               L_PAREN "("
               DOCUMENT_KW "document"
               WHITESPACE " "
@@ -1340,9 +1319,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            XML_SERIALIZE_FN
               XMLSERIALIZE_KW "xmlserialize"
-            ARG_LIST
               L_PAREN "("
               DOCUMENT_KW "document"
               WHITESPACE " "
@@ -1372,9 +1350,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               R_PAREN ")"
   SEMICOLON ";"
@@ -1386,9 +1363,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               LITERAL
                 STRING "'{a, 1, b, \"def\", c, 3.5}'"
@@ -1402,9 +1378,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               LITERAL
                 STRING "'{foo}'"
@@ -1422,9 +1397,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               ARRAY_EXPR
                 ARRAY_KW "array"
@@ -1458,9 +1432,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1490,9 +1463,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1520,9 +1492,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1551,9 +1522,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1577,9 +1547,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1605,9 +1574,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1633,9 +1601,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1678,9 +1645,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1713,9 +1679,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1746,9 +1711,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1781,9 +1745,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1814,9 +1777,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1844,9 +1806,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_OBJECT_FN
               JSON_OBJECT_KW "json_object"
-            ARG_LIST
               L_PAREN "("
               JSON_KEY_VALUE
                 LITERAL
@@ -1883,9 +1844,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -1899,9 +1859,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               LITERAL
                 INT_NUMBER "1"
@@ -1927,9 +1886,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               PAREN_EXPR
                 L_PAREN "("
@@ -1949,9 +1907,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -1975,9 +1932,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -1996,9 +1952,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -2024,9 +1979,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               LITERAL
                 INT_NUMBER "1"
@@ -2054,9 +2008,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -2077,9 +2030,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -2114,9 +2066,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               LITERAL
                 INT_NUMBER "1"
@@ -2145,9 +2096,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               LITERAL
                 INT_NUMBER "1"
@@ -2180,9 +2130,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               SELECT
                 SELECT_CLAUSE
@@ -2204,9 +2153,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               SELECT_INTO
                 SELECT_CLAUSE
@@ -2238,9 +2186,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               SELECT
                 SELECT_CLAUSE
@@ -2260,9 +2207,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               SELECT
                 SELECT_CLAUSE
@@ -2287,9 +2233,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               SELECT
                 SELECT_CLAUSE
@@ -2328,9 +2273,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               SELECT
                 SELECT_CLAUSE
@@ -2364,9 +2308,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               PAREN_EXPR
                 L_PAREN "("
@@ -2392,9 +2335,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               JSON_RETURNING_CLAUSE
                 RETURNING_KW "returning"
@@ -2414,9 +2356,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_ARRAY_FN
               JSON_ARRAY_KW "json_array"
-            ARG_LIST
               L_PAREN "("
               JSON_RETURNING_CLAUSE
                 RETURNING_KW "returning"
@@ -2443,9 +2384,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_SCALAR_FN
               JSON_SCALAR_KW "json_scalar"
-            ARG_LIST
               L_PAREN "("
               LITERAL
                 INT_NUMBER "1"
@@ -2461,9 +2401,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXISTS_FN
               EXISTS_KW "exists"
-            ARG_LIST
               L_PAREN "("
               SELECT
                 SELECT_CLAUSE
@@ -2502,9 +2441,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXISTS_FN
               EXISTS_KW "exists"
-            ARG_LIST
               L_PAREN "("
               SELECT
                 WITH_CLAUSE
@@ -2552,9 +2490,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXISTS_FN
               EXISTS_KW "exists"
-            ARG_LIST
               L_PAREN "("
               VALUES
                 VALUES_KW "values"
@@ -2589,9 +2526,8 @@ SOURCE_FILE
       WHERE_KW "where"
       WHITESPACE " "
       CALL_EXPR
-        NAME_REF
+        EXISTS_FN
           EXISTS_KW "exists"
-        ARG_LIST
           L_PAREN "("
           SELECT
             SELECT_CLAUSE
@@ -2616,9 +2552,8 @@ SOURCE_FILE
             NOT_KW "not"
             WHITESPACE " "
             CALL_EXPR
-              NAME_REF
+              EXISTS_FN
                 EXISTS_KW "exists"
-              ARG_LIST
                 L_PAREN "("
                 SELECT
                   SELECT_CLAUSE
@@ -2758,9 +2693,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               IDENT "foo"
               WHITESPACE " "
@@ -2786,9 +2720,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               YEAR_KW "year"
               WHITESPACE " "
@@ -2806,9 +2739,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               MONTH_KW "month"
               WHITESPACE " "
@@ -2826,9 +2758,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               DAY_KW "day"
               WHITESPACE " "
@@ -2846,9 +2777,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               HOUR_KW "hour"
               WHITESPACE " "
@@ -2866,9 +2796,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               MINUTE_KW "minute"
               WHITESPACE " "
@@ -2886,9 +2815,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               SECOND_KW "second"
               WHITESPACE " "
@@ -2906,9 +2834,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               STRING "'minute'"
               WHITESPACE " "
@@ -2926,9 +2853,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               IDENT "epoch"
               WHITESPACE " "
@@ -2953,9 +2879,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               IDENT "century"
               WHITESPACE " "
@@ -2977,9 +2902,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               IDENT "isodow"
               WHITESPACE " "
@@ -3001,9 +2925,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               IDENT "isoyear"
               WHITESPACE " "
@@ -3028,9 +2951,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               IDENT "julian"
               WHITESPACE " "
@@ -3055,9 +2977,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               IDENT "microseconds"
               WHITESPACE " "
@@ -3079,9 +3000,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               IDENT "millennium"
               WHITESPACE " "
@@ -3103,9 +3023,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            EXTRACT_FN
               EXTRACT_KW "extract"
-            ARG_LIST
               L_PAREN "("
               IDENT "quarter"
               WHITESPACE " "
diff --git a/crates/squawk_parser/tests/snapshots/tests__select_funcs_pg17_ok.snap b/crates/squawk_parser/tests/snapshots/tests__select_funcs_pg17_ok.snap
index bc27ff50..dbad24f2 100644
--- a/crates/squawk_parser/tests/snapshots/tests__select_funcs_pg17_ok.snap
+++ b/crates/squawk_parser/tests/snapshots/tests__select_funcs_pg17_ok.snap
@@ -27,91 +27,92 @@ SOURCE_FILE
       COMMA ","
       WHITESPACE "\n "
       FROM_ITEM
-        CALL_EXPR
+        JSON_TABLE
+          JSON_TABLE_KW "JSON_TABLE"
+          WHITESPACE " "
+          L_PAREN "("
           NAME_REF
-            JSON_TABLE_KW "JSON_TABLE"
+            IDENT "js"
+          COMMA ","
+          WHITESPACE " "
+          LITERAL
+            STRING "'$.favorites[*]'"
           WHITESPACE " "
-          ARG_LIST
+          JSON_TABLE_COLUMN_LIST
+            COLUMNS_KW "COLUMNS"
+            WHITESPACE " "
             L_PAREN "("
-            NAME_REF
-              IDENT "js"
+            WHITESPACE "\n   "
+            JSON_TABLE_COLUMN
+              NAME
+                IDENT "id"
+              WHITESPACE " "
+              FOR_KW "FOR"
+              WHITESPACE " "
+              ORDINALITY_KW "ORDINALITY"
             COMMA ","
-            WHITESPACE " "
-            LITERAL
-              STRING "'$.favorites[*]'"
-            WHITESPACE " "
-            JSON_TABLE_COLUMN_LIST
-              COLUMNS_KW "COLUMNS"
+            WHITESPACE "\n   "
+            JSON_TABLE_COLUMN
+              NAME
+                IDENT "kind"
               WHITESPACE " "
-              L_PAREN "("
-              WHITESPACE "\n   "
-              JSON_TABLE_COLUMN
-                NAME
-                  IDENT "id"
-                WHITESPACE " "
-                FOR_KW "FOR"
-                WHITESPACE " "
-                ORDINALITY_KW "ORDINALITY"
-              COMMA ","
-              WHITESPACE "\n   "
-              JSON_TABLE_COLUMN
-                NAME
-                  IDENT "kind"
-                WHITESPACE " "
-                PATH_TYPE
-                  PATH
-                    PATH_SEGMENT
-                      NAME_REF
-                        TEXT_KW "text"
-                WHITESPACE " "
+              PATH_TYPE
+                PATH
+                  PATH_SEGMENT
+                    NAME_REF
+                      TEXT_KW "text"
+              WHITESPACE " "
+              JSON_PATH_CLAUSE
                 PATH_KW "PATH"
                 WHITESPACE " "
                 LITERAL
                   STRING "'$.kind'"
-              COMMA ","
-              WHITESPACE "\n   "
-              JSON_TABLE_COLUMN
-                NAME
-                  IDENT "title"
-                WHITESPACE " "
-                PATH_TYPE
-                  PATH
-                    PATH_SEGMENT
-                      NAME_REF
-                        TEXT_KW "text"
-                WHITESPACE " "
+            COMMA ","
+            WHITESPACE "\n   "
+            JSON_TABLE_COLUMN
+              NAME
+                IDENT "title"
+              WHITESPACE " "
+              PATH_TYPE
+                PATH
+                  PATH_SEGMENT
+                    NAME_REF
+                      TEXT_KW "text"
+              WHITESPACE " "
+              JSON_PATH_CLAUSE
                 PATH_KW "PATH"
                 WHITESPACE " "
                 LITERAL
                   STRING "'$.films[*].title'"
+              WHITESPACE " "
+              JSON_WRAPPER_BEHAVIOR_CLAUSE
+                WITH_KW "WITH"
                 WHITESPACE " "
-                JSON_WRAPPER_BEHAVIOR_CLAUSE
-                  WITH_KW "WITH"
-                  WHITESPACE " "
-                  WRAPPER_KW "WRAPPER"
-              COMMA ","
-              WHITESPACE "\n   "
-              JSON_TABLE_COLUMN
-                NAME
-                  IDENT "director"
-                WHITESPACE " "
-                PATH_TYPE
-                  PATH
-                    PATH_SEGMENT
-                      NAME_REF
-                        TEXT_KW "text"
-                WHITESPACE " "
+                WRAPPER_KW "WRAPPER"
+            COMMA ","
+            WHITESPACE "\n   "
+            JSON_TABLE_COLUMN
+              NAME
+                IDENT "director"
+              WHITESPACE " "
+              PATH_TYPE
+                PATH
+                  PATH_SEGMENT
+                    NAME_REF
+                      TEXT_KW "text"
+              WHITESPACE " "
+              JSON_PATH_CLAUSE
                 PATH_KW "PATH"
                 WHITESPACE " "
                 LITERAL
                   STRING "'$.films[*].director'"
+              WHITESPACE " "
+              JSON_WRAPPER_BEHAVIOR_CLAUSE
+                WITH_KW "WITH"
                 WHITESPACE " "
-                JSON_WRAPPER_BEHAVIOR_CLAUSE
-                  WITH_KW "WITH"
-                  WHITESPACE " "
-                  WRAPPER_KW "WRAPPER"
-              R_PAREN ")"
+                WRAPPER_KW "WRAPPER"
             R_PAREN ")"
+          R_PAREN ")"
         WHITESPACE " "
         ALIAS
           AS_KW "AS"
@@ -143,123 +144,124 @@ SOURCE_FILE
       COMMA ","
       WHITESPACE "\n "
       FROM_ITEM
-        CALL_EXPR
+        JSON_TABLE
+          JSON_TABLE_KW "JSON_TABLE"
+          WHITESPACE " "
+          L_PAREN "("
+          WHITESPACE " "
           NAME_REF
-            JSON_TABLE_KW "JSON_TABLE"
+            IDENT "js"
+          COMMA ","
           WHITESPACE " "
-          ARG_LIST
-            L_PAREN "("
+          LITERAL
+            STRING "'$.favorites[*] ? (@.films[*].director == $filter)'"
+          WHITESPACE "\n   "
+          JSON_PASSING_CLAUSE
+            PASSING_KW "PASSING"
             WHITESPACE " "
-            NAME_REF
-              IDENT "js"
-            COMMA ","
+            JSON_PASSING_ARG
+              LITERAL
+                STRING "'Alfred Hitchcock'"
+              WHITESPACE " "
+              AS_KW "AS"
+              WHITESPACE " "
+              NAME
+                FILTER_KW "filter"
+          WHITESPACE "\n   "
+          JSON_TABLE_COLUMN_LIST
+            COLUMNS_KW "COLUMNS"
             WHITESPACE " "
-            LITERAL
-              STRING "'$.favorites[*] ? (@.films[*].director == $filter)'"
-            WHITESPACE "\n   "
-            JSON_PASSING_CLAUSE
-              PASSING_KW "PASSING"
+            L_PAREN "("
+            WHITESPACE "\n    "
+            JSON_TABLE_COLUMN
+              NAME
+                IDENT "id"
               WHITESPACE " "
-              JSON_PASSING_ARG
-                LITERAL
-                  STRING "'Alfred Hitchcock'"
-                WHITESPACE " "
-                AS_KW "AS"
-                WHITESPACE " "
-                NAME
-                  FILTER_KW "filter"
-            WHITESPACE "\n   "
-            JSON_TABLE_COLUMN_LIST
-              COLUMNS_KW "COLUMNS"
+              FOR_KW "FOR"
               WHITESPACE " "
-              L_PAREN "("
-              WHITESPACE "\n    "
-              JSON_TABLE_COLUMN
-                NAME
-                  IDENT "id"
-                WHITESPACE " "
-                FOR_KW "FOR"
-                WHITESPACE " "
-                ORDINALITY_KW "ORDINALITY"
-              COMMA ","
-              WHITESPACE "\n    "
-              JSON_TABLE_COLUMN
-                NAME
-                  IDENT "kind"
-                WHITESPACE " "
-                PATH_TYPE
-                  PATH
-                    PATH_SEGMENT
-                      NAME_REF
-                        TEXT_KW "text"
-                WHITESPACE " "
+              ORDINALITY_KW "ORDINALITY"
+            COMMA ","
+            WHITESPACE "\n    "
+            JSON_TABLE_COLUMN
+              NAME
+                IDENT "kind"
+              WHITESPACE " "
+              PATH_TYPE
+                PATH
+                  PATH_SEGMENT
+                    NAME_REF
+                      TEXT_KW "text"
+              WHITESPACE " "
+              JSON_PATH_CLAUSE
                 PATH_KW "PATH"
                 WHITESPACE " "
                 LITERAL
                   STRING "'$.kind'"
-              COMMA ","
-              WHITESPACE "\n    "
-              JSON_TABLE_COLUMN
-                NESTED_KW "NESTED"
-                WHITESPACE " "
-                PATH_KW "PATH"
-                WHITESPACE " "
-                LITERAL
-                  STRING "'$.films[*]'"
+            COMMA ","
+            WHITESPACE "\n    "
+            JSON_TABLE_COLUMN
+              NESTED_KW "NESTED"
+              WHITESPACE " "
+              PATH_KW "PATH"
+              WHITESPACE " "
+              LITERAL
+                STRING "'$.films[*]'"
+              WHITESPACE " "
+              JSON_TABLE_COLUMN_LIST
+                COLUMNS_KW "COLUMNS"
                 WHITESPACE " "
-                JSON_TABLE_COLUMN_LIST
-                  COLUMNS_KW "COLUMNS"
+                L_PAREN "("
+                WHITESPACE "\n      "
+                JSON_TABLE_COLUMN
+                  NAME
+                    IDENT "title"
                   WHITESPACE " "
-                  L_PAREN "("
-                  WHITESPACE "\n      "
-                  JSON_TABLE_COLUMN
-                    NAME
-                      IDENT "title"
-                    WHITESPACE " "
-                    PATH_TYPE
-                      PATH
-                        PATH_SEGMENT
-                          NAME_REF
-                            TEXT_KW "text"
-                    WHITESPACE " "
-                    JSON_FORMAT_CLAUSE
-                      FORMAT_KW "FORMAT"
-                      WHITESPACE " "
-                      JSON_KW "JSON"
+                  PATH_TYPE
+                    PATH
+                      PATH_SEGMENT
+                        NAME_REF
+                          TEXT_KW "text"
+                  WHITESPACE " "
+                  JSON_FORMAT_CLAUSE
+                    FORMAT_KW "FORMAT"
                     WHITESPACE " "
+                    JSON_KW "JSON"
+                  WHITESPACE " "
+                  JSON_PATH_CLAUSE
                     PATH_KW "PATH"
                     WHITESPACE " "
                     LITERAL
                       STRING "'$.title'"
+                  WHITESPACE " "
+                  JSON_QUOTES_CLAUSE
+                    OMIT_KW "OMIT"
                     WHITESPACE " "
-                    JSON_QUOTES_CLAUSE
-                      OMIT_KW "OMIT"
-                      WHITESPACE " "
-                      QUOTES_KW "QUOTES"
-                  COMMA ","
-                  WHITESPACE "\n      "
-                  JSON_TABLE_COLUMN
-                    NAME
-                      IDENT "director"
-                    WHITESPACE " "
-                    PATH_TYPE
-                      PATH
-                        PATH_SEGMENT
-                          NAME_REF
-                            TEXT_KW "text"
-                    WHITESPACE " "
+                    QUOTES_KW "QUOTES"
+                COMMA ","
+                WHITESPACE "\n      "
+                JSON_TABLE_COLUMN
+                  NAME
+                    IDENT "director"
+                  WHITESPACE " "
+                  PATH_TYPE
+                    PATH
+                      PATH_SEGMENT
+                        NAME_REF
+                          TEXT_KW "text"
+                  WHITESPACE " "
+                  JSON_PATH_CLAUSE
                     PATH_KW "PATH"
                     WHITESPACE " "
                     LITERAL
                       STRING "'$.director'"
+                  WHITESPACE " "
+                  JSON_QUOTES_CLAUSE
+                    KEEP_KW "KEEP"
                     WHITESPACE " "
-                    JSON_QUOTES_CLAUSE
-                      KEEP_KW "KEEP"
-                      WHITESPACE " "
-                      QUOTES_KW "QUOTES"
-                  R_PAREN ")"
-              R_PAREN ")"
+                    QUOTES_KW "QUOTES"
+                R_PAREN ")"
             R_PAREN ")"
+          R_PAREN ")"
         WHITESPACE " "
         ALIAS
           AS_KW "AS"
@@ -291,111 +293,112 @@ SOURCE_FILE
       COMMA ","
       WHITESPACE "\n "
       FROM_ITEM
-        CALL_EXPR
+        JSON_TABLE
+          JSON_TABLE_KW "JSON_TABLE"
+          WHITESPACE " "
+          L_PAREN "("
+          WHITESPACE " "
           NAME_REF
-            JSON_TABLE_KW "JSON_TABLE"
+            IDENT "js"
+          COMMA ","
           WHITESPACE " "
-          ARG_LIST
-            L_PAREN "("
+          LITERAL
+            STRING "'$.favorites[*]'"
+          WHITESPACE "\n   "
+          JSON_TABLE_COLUMN_LIST
+            COLUMNS_KW "COLUMNS"
             WHITESPACE " "
-            NAME_REF
-              IDENT "js"
+            L_PAREN "("
+            WHITESPACE "\n    "
+            JSON_TABLE_COLUMN
+              NAME
+                IDENT "id"
+              WHITESPACE " "
+              FOR_KW "FOR"
+              WHITESPACE " "
+              ORDINALITY_KW "ORDINALITY"
             COMMA ","
-            WHITESPACE " "
-            LITERAL
-              STRING "'$.favorites[*]'"
-            WHITESPACE "\n   "
-            JSON_TABLE_COLUMN_LIST
-              COLUMNS_KW "COLUMNS"
+            WHITESPACE "\n    "
+            JSON_TABLE_COLUMN
+              NAME
+                IDENT "kind"
               WHITESPACE " "
-              L_PAREN "("
-              WHITESPACE "\n    "
-              JSON_TABLE_COLUMN
-                NAME
-                  IDENT "id"
-                WHITESPACE " "
-                FOR_KW "FOR"
-                WHITESPACE " "
-                ORDINALITY_KW "ORDINALITY"
-              COMMA ","
-              WHITESPACE "\n    "
-              JSON_TABLE_COLUMN
-                NAME
-                  IDENT "kind"
-                WHITESPACE " "
-                PATH_TYPE
-                  PATH
-                    PATH_SEGMENT
-                      NAME_REF
-                        TEXT_KW "text"
-                WHITESPACE " "
+              PATH_TYPE
+                PATH
+                  PATH_SEGMENT
+                    NAME_REF
+                      TEXT_KW "text"
+              WHITESPACE " "
+              JSON_PATH_CLAUSE
                 PATH_KW "PATH"
                 WHITESPACE " "
                 LITERAL
                   STRING "'$.kind'"
-              COMMA ","
-              WHITESPACE "\n    "
-              JSON_TABLE_COLUMN
-                NESTED_KW "NESTED"
-                WHITESPACE " "
-                PATH_KW "PATH"
-                WHITESPACE " "
-                LITERAL
-                  STRING "'$.films[*]'"
+            COMMA ","
+            WHITESPACE "\n    "
+            JSON_TABLE_COLUMN
+              NESTED_KW "NESTED"
+              WHITESPACE " "
+              PATH_KW "PATH"
+              WHITESPACE " "
+              LITERAL
+                STRING "'$.films[*]'"
+              WHITESPACE " "
+              JSON_TABLE_COLUMN_LIST
+                COLUMNS_KW "COLUMNS"
                 WHITESPACE " "
-                JSON_TABLE_COLUMN_LIST
-                  COLUMNS_KW "COLUMNS"
+                L_PAREN "("
+                WHITESPACE "\n      "
+                JSON_TABLE_COLUMN
+                  NAME
+                    IDENT "title"
                   WHITESPACE " "
-                  L_PAREN "("
-                  WHITESPACE "\n      "
-                  JSON_TABLE_COLUMN
-                    NAME
-                      IDENT "title"
-                    WHITESPACE " "
-                    PATH_TYPE
-                      PATH
-                        PATH_SEGMENT
-                          NAME_REF
-                            TEXT_KW "text"
-                    WHITESPACE " "
-                    JSON_FORMAT_CLAUSE
-                      FORMAT_KW "FORMAT"
-                      WHITESPACE " "
-                      JSON_KW "JSON"
+                  PATH_TYPE
+                    PATH
+                      PATH_SEGMENT
+                        NAME_REF
+                          TEXT_KW "text"
+                  WHITESPACE " "
+                  JSON_FORMAT_CLAUSE
+                    FORMAT_KW "FORMAT"
                     WHITESPACE " "
+                    JSON_KW "JSON"
+                  WHITESPACE " "
+                  JSON_PATH_CLAUSE
                     PATH_KW "PATH"
                     WHITESPACE " "
                     LITERAL
                       STRING "'$.title'"
+                  WHITESPACE " "
+                  JSON_QUOTES_CLAUSE
+                    OMIT_KW "OMIT"
                     WHITESPACE " "
-                    JSON_QUOTES_CLAUSE
-                      OMIT_KW "OMIT"
-                      WHITESPACE " "
-                      QUOTES_KW "QUOTES"
-                  COMMA ","
-                  WHITESPACE "\n      "
-                  JSON_TABLE_COLUMN
-                    NAME
-                      IDENT "director"
-                    WHITESPACE " "
-                    PATH_TYPE
-                      PATH
-                        PATH_SEGMENT
-                          NAME_REF
-                            TEXT_KW "text"
-                    WHITESPACE " "
+                    QUOTES_KW "QUOTES"
+                COMMA ","
+                WHITESPACE "\n      "
+                JSON_TABLE_COLUMN
+                  NAME
+                    IDENT "director"
+                  WHITESPACE " "
+                  PATH_TYPE
+                    PATH
+                      PATH_SEGMENT
+                        NAME_REF
+                          TEXT_KW "text"
+                  WHITESPACE " "
+                  JSON_PATH_CLAUSE
                     PATH_KW "PATH"
                     WHITESPACE " "
                     LITERAL
                       STRING "'$.director'"
+                  WHITESPACE " "
+                  JSON_QUOTES_CLAUSE
+                    KEEP_KW "KEEP"
                     WHITESPACE " "
-                    JSON_QUOTES_CLAUSE
-                      KEEP_KW "KEEP"
-                      WHITESPACE " "
-                      QUOTES_KW "QUOTES"
-                  R_PAREN ")"
-              R_PAREN ")"
+                    QUOTES_KW "QUOTES"
+                R_PAREN ")"
             R_PAREN ")"
+          R_PAREN ")"
         WHITESPACE " "
         ALIAS
           AS_KW "AS"
@@ -418,165 +421,166 @@ SOURCE_FILE
       FROM_KW "FROM"
       WHITESPACE " "
       FROM_ITEM
-        CALL_EXPR
-          NAME_REF
-            JSON_TABLE_KW "JSON_TABLE"
+        JSON_TABLE
+          JSON_TABLE_KW "JSON_TABLE"
+          WHITESPACE " "
+          L_PAREN "("
+          WHITESPACE "\n"
+          CAST_EXPR
+            LITERAL
+              STRING "'{\"favorites\":\n    {\"movies\":\n      [{\"name\": \"One\", \"director\": \"John Doe\"},\n       {\"name\": \"Two\", \"director\": \"Don Joe\"}],\n     \"books\":\n      [{\"name\": \"Mystery\", \"authors\": [{\"name\": \"Brown Dan\"}]},\n       {\"name\": \"Wonder\", \"authors\": [{\"name\": \"Jun Murakami\"}, {\"name\":\"Craig Doe\"}]}]\n}}'"
+            COLON_COLON
+              COLON ":"
+              COLON ":"
+            PATH_TYPE
+              PATH
+                PATH_SEGMENT
+                  NAME_REF
+                    JSON_KW "json"
+          COMMA ","
           WHITESPACE " "
-          ARG_LIST
+          LITERAL
+            STRING "'$.favorites[*]'"
+          WHITESPACE "\n"
+          JSON_TABLE_COLUMN_LIST
+            COLUMNS_KW "COLUMNS"
+            WHITESPACE " "
             L_PAREN "("
-            WHITESPACE "\n"
-            CAST_EXPR
-              LITERAL
-                STRING "'{\"favorites\":\n    {\"movies\":\n      [{\"name\": \"One\", \"director\": \"John Doe\"},\n       {\"name\": \"Two\", \"director\": \"Don Joe\"}],\n     \"books\":\n      [{\"name\": \"Mystery\", \"authors\": [{\"name\": \"Brown Dan\"}]},\n       {\"name\": \"Wonder\", \"authors\": [{\"name\": \"Jun Murakami\"}, {\"name\":\"Craig Doe\"}]}]\n}}'"
-              COLON_COLON
-                COLON ":"
-                COLON ":"
-              PATH_TYPE
-                PATH
-                  PATH_SEGMENT
-                    NAME_REF
-                      JSON_KW "json"
+            WHITESPACE "\n  "
+            JSON_TABLE_COLUMN
+              NAME
+                IDENT "user_id"
+              WHITESPACE " "
+              FOR_KW "FOR"
+              WHITESPACE " "
+              ORDINALITY_KW "ORDINALITY"
             COMMA ","
-            WHITESPACE " "
-            LITERAL
-              STRING "'$.favorites[*]'"
-            WHITESPACE "\n"
-            JSON_TABLE_COLUMN_LIST
-              COLUMNS_KW "COLUMNS"
+            WHITESPACE "\n  "
+            JSON_TABLE_COLUMN
+              NESTED_KW "NESTED"
               WHITESPACE " "
-              L_PAREN "("
-              WHITESPACE "\n  "
-              JSON_TABLE_COLUMN
-                NAME
-                  IDENT "user_id"
-                WHITESPACE " "
-                FOR_KW "FOR"
-                WHITESPACE " "
-                ORDINALITY_KW "ORDINALITY"
-              COMMA ","
-              WHITESPACE "\n  "
-              JSON_TABLE_COLUMN
-                NESTED_KW "NESTED"
+              LITERAL
+                STRING "'$.movies[*]'"
+              WHITESPACE "\n    "
+              JSON_TABLE_COLUMN_LIST
+                COLUMNS_KW "COLUMNS"
                 WHITESPACE " "
-                LITERAL
-                  STRING "'$.movies[*]'"
+                L_PAREN "("
                 WHITESPACE "\n    "
-                JSON_TABLE_COLUMN_LIST
-                  COLUMNS_KW "COLUMNS"
+                JSON_TABLE_COLUMN
+                  NAME
+                    IDENT "movie_id"
                   WHITESPACE " "
-                  L_PAREN "("
-                  WHITESPACE "\n    "
-                  JSON_TABLE_COLUMN
-                    NAME
-                      IDENT "movie_id"
-                    WHITESPACE " "
-                    FOR_KW "FOR"
-                    WHITESPACE " "
-                    ORDINALITY_KW "ORDINALITY"
-                  COMMA ","
-                  WHITESPACE "\n    "
-                  JSON_TABLE_COLUMN
-                    NAME
-                      IDENT "mname"
-                    WHITESPACE " "
-                    PATH_TYPE
-                      PATH
-                        PATH_SEGMENT
-                          NAME_REF
-                            TEXT_KW "text"
-                    WHITESPACE " "
+                  FOR_KW "FOR"
+                  WHITESPACE " "
+                  ORDINALITY_KW "ORDINALITY"
+                COMMA ","
+                WHITESPACE "\n    "
+                JSON_TABLE_COLUMN
+                  NAME
+                    IDENT "mname"
+                  WHITESPACE " "
+                  PATH_TYPE
+                    PATH
+                      PATH_SEGMENT
+                        NAME_REF
+                          TEXT_KW "text"
+                  WHITESPACE " "
+                  JSON_PATH_CLAUSE
                     PATH_KW "PATH"
                     WHITESPACE " "
                     LITERAL
                       STRING "'$.name'"
-                  COMMA ","
-                  WHITESPACE "\n    "
-                  JSON_TABLE_COLUMN
-                    NAME
-                      IDENT "director"
-                    WHITESPACE " "
-                    PATH_TYPE
-                      PATH
-                        PATH_SEGMENT
-                          NAME_REF
-                            TEXT_KW "text"
-                  R_PAREN ")"
-              COMMA ","
-              WHITESPACE "\n  "
-              JSON_TABLE_COLUMN
-                NESTED_KW "NESTED"
-                WHITESPACE " "
-                LITERAL
-                  STRING "'$.books[*]'"
+                COMMA ","
                 WHITESPACE "\n    "
-                JSON_TABLE_COLUMN_LIST
-                  COLUMNS_KW "COLUMNS"
+                JSON_TABLE_COLUMN
+                  NAME
+                    IDENT "director"
                   WHITESPACE " "
-                  L_PAREN "("
-                  WHITESPACE "\n      "
-                  JSON_TABLE_COLUMN
-                    NAME
-                      IDENT "book_id"
-                    WHITESPACE " "
-                    FOR_KW "FOR"
-                    WHITESPACE " "
-                    ORDINALITY_KW "ORDINALITY"
-                  COMMA ","
-                  WHITESPACE "\n      "
-                  JSON_TABLE_COLUMN
-                    NAME
-                      IDENT "bname"
-                    WHITESPACE " "
-                    PATH_TYPE
-                      PATH
-                        PATH_SEGMENT
-                          NAME_REF
-                            TEXT_KW "text"
-                    WHITESPACE " "
+                  PATH_TYPE
+                    PATH
+                      PATH_SEGMENT
+                        NAME_REF
+                          TEXT_KW "text"
+                R_PAREN ")"
+            COMMA ","
+            WHITESPACE "\n  "
+            JSON_TABLE_COLUMN
+              NESTED_KW "NESTED"
+              WHITESPACE " "
+              LITERAL
+                STRING "'$.books[*]'"
+              WHITESPACE "\n    "
+              JSON_TABLE_COLUMN_LIST
+                COLUMNS_KW "COLUMNS"
+                WHITESPACE " "
+                L_PAREN "("
+                WHITESPACE "\n      "
+                JSON_TABLE_COLUMN
+                  NAME
+                    IDENT "book_id"
+                  WHITESPACE " "
+                  FOR_KW "FOR"
+                  WHITESPACE " "
+                  ORDINALITY_KW "ORDINALITY"
+                COMMA ","
+                WHITESPACE "\n      "
+                JSON_TABLE_COLUMN
+                  NAME
+                    IDENT "bname"
+                  WHITESPACE " "
+                  PATH_TYPE
+                    PATH
+                      PATH_SEGMENT
+                        NAME_REF
+                          TEXT_KW "text"
+                  WHITESPACE " "
+                  JSON_PATH_CLAUSE
                     PATH_KW "PATH"
                     WHITESPACE " "
                     LITERAL
                       STRING "'$.name'"
-                  COMMA ","
-                  WHITESPACE "\n      "
-                  JSON_TABLE_COLUMN
-                    NESTED_KW "NESTED"
+                COMMA ","
+                WHITESPACE "\n      "
+                JSON_TABLE_COLUMN
+                  NESTED_KW "NESTED"
+                  WHITESPACE " "
+                  LITERAL
+                    STRING "'$.authors[*]'"
+                  WHITESPACE "\n        "
+                  JSON_TABLE_COLUMN_LIST
+                    COLUMNS_KW "COLUMNS"
                     WHITESPACE " "
-                    LITERAL
-                      STRING "'$.authors[*]'"
-                    WHITESPACE "\n        "
-                    JSON_TABLE_COLUMN_LIST
-                      COLUMNS_KW "COLUMNS"
+                    L_PAREN "("
+                    WHITESPACE "\n          "
+                    JSON_TABLE_COLUMN
+                      NAME
+                        IDENT "author_id"
                       WHITESPACE " "
-                      L_PAREN "("
-                      WHITESPACE "\n          "
-                      JSON_TABLE_COLUMN
-                        NAME
-                          IDENT "author_id"
-                        WHITESPACE " "
-                        FOR_KW "FOR"
-                        WHITESPACE " "
-                        ORDINALITY_KW "ORDINALITY"
-                      COMMA ","
-                      WHITESPACE "\n          "
-                      JSON_TABLE_COLUMN
-                        NAME
-                          IDENT "author_name"
-                        WHITESPACE " "
-                        PATH_TYPE
-                          PATH
-                            PATH_SEGMENT
-                              NAME_REF
-                                TEXT_KW "text"
-                        WHITESPACE " "
+                      FOR_KW "FOR"
+                      WHITESPACE " "
+                      ORDINALITY_KW "ORDINALITY"
+                    COMMA ","
+                    WHITESPACE "\n          "
+                    JSON_TABLE_COLUMN
+                      NAME
+                        IDENT "author_name"
+                      WHITESPACE " "
+                      PATH_TYPE
+                        PATH
+                          PATH_SEGMENT
+                            NAME_REF
+                              TEXT_KW "text"
+                      WHITESPACE " "
+                      JSON_PATH_CLAUSE
                         PATH_KW "PATH"
                         WHITESPACE " "
                         LITERAL
                           STRING "'$.name'"
-                      R_PAREN ")"
-                  R_PAREN ")"
-              R_PAREN ")"
+                    R_PAREN ")"
+                R_PAREN ")"
             R_PAREN ")"
+          R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- json"
@@ -588,9 +592,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_FN
               JSON_KW "json"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -609,9 +612,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_FN
               JSON_KW "json"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -637,9 +639,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_FN
               JSON_KW "json"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -663,9 +664,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_FN
               JSON_KW "json"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -691,9 +691,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_FN
               JSON_KW "json"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -719,9 +718,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_SERIALIZE_FN
               JSON_SERIALIZE_KW "json_serialize"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -735,9 +733,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_SERIALIZE_FN
               JSON_SERIALIZE_KW "json_serialize"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -756,9 +753,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_SERIALIZE_FN
               JSON_SERIALIZE_KW "json_serialize"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -781,9 +777,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_SERIALIZE_FN
               JSON_SERIALIZE_KW "json_serialize"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -818,9 +813,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_QUERY_FN
               JSON_QUERY_KW "json_query"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -843,9 +837,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_QUERY_FN
               JSON_QUERY_KW "json_query"
-            ARG_LIST
               L_PAREN "("
               WHITESPACE "\n  "
               NAME_REF
@@ -946,9 +939,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_EXISTS_FN
               JSON_EXISTS_KW "json_exists"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -966,9 +958,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_EXISTS_FN
               JSON_EXISTS_KW "json_exists"
-            ARG_LIST
               L_PAREN "("
               WHITESPACE "\n  "
               NAME_REF
@@ -1018,9 +1009,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_EXISTS_FN
               JSON_EXISTS_KW "JSON_EXISTS"
-            ARG_LIST
               L_PAREN "("
               CAST_EXPR
                 PATH_TYPE
@@ -1057,9 +1047,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_EXISTS_FN
               JSON_EXISTS_KW "JSON_EXISTS"
-            ARG_LIST
               L_PAREN "("
               CAST_EXPR
                 PATH_TYPE
@@ -1092,9 +1081,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_EXISTS_FN
               JSON_EXISTS_KW "JSON_EXISTS"
-            ARG_LIST
               L_PAREN "("
               CAST_EXPR
                 PATH_TYPE
@@ -1129,9 +1117,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_VALUE_FN
               JSON_VALUE_KW "json_value"
-            ARG_LIST
               L_PAREN "("
               NAME_REF
                 IDENT "a"
@@ -1149,9 +1136,8 @@ SOURCE_FILE
       TARGET_LIST
         TARGET
           CALL_EXPR
-            NAME_REF
+            JSON_VALUE_FN
               JSON_VALUE_KW "json_value"
-            ARG_LIST
               L_PAREN "("
               WHITESPACE "\n  "
               NAME_REF
diff --git a/crates/squawk_parser/tests/snapshots/tests__select_ok.snap b/crates/squawk_parser/tests/snapshots/tests__select_ok.snap
index bbdf4f19..a06a3470 100644
--- a/crates/squawk_parser/tests/snapshots/tests__select_ok.snap
+++ b/crates/squawk_parser/tests/snapshots/tests__select_ok.snap
@@ -628,12 +628,12 @@ SOURCE_FILE
         EQ "="
         WHITESPACE " "
         CALL_EXPR
-          NAME_REF
+          ALL_FN
             ALL_KW "all"
-          L_PAREN "("
-          NAME_REF
-            IDENT "c"
-          R_PAREN ")"
+            L_PAREN "("
+            NAME_REF
+              IDENT "c"
+            R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- any"
@@ -663,12 +663,12 @@ SOURCE_FILE
         EQ "="
         WHITESPACE " "
         CALL_EXPR
-          NAME_REF
+          ANY_FN
             ANY_KW "any"
-          L_PAREN "("
-          NAME_REF
-            IDENT "c"
-          R_PAREN ")"
+            L_PAREN "("
+            NAME_REF
+              IDENT "c"
+            R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   SELECT
@@ -696,24 +696,24 @@ SOURCE_FILE
         EQ "="
         WHITESPACE " "
         CALL_EXPR
-          NAME_REF
+          ANY_FN
             ANY_KW "any"
-          L_PAREN "("
-          ARRAY_EXPR
-            ARRAY_KW "array"
-            L_BRACK "["
-            LITERAL
-              STRING "'a'"
-            COMMA ","
-            WHITESPACE " "
-            LITERAL
-              STRING "'b'"
-            COMMA ","
-            WHITESPACE " "
-            LITERAL
-              STRING "'c'"
-            R_BRACK "]"
-          R_PAREN ")"
+            L_PAREN "("
+            ARRAY_EXPR
+              ARRAY_KW "array"
+              L_BRACK "["
+              LITERAL
+                STRING "'a'"
+              COMMA ","
+              WHITESPACE " "
+              LITERAL
+                STRING "'b'"
+              COMMA ","
+              WHITESPACE " "
+              LITERAL
+                STRING "'c'"
+              R_BRACK "]"
+            R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   SELECT
@@ -729,18 +729,18 @@ SOURCE_FILE
             EQ "="
             WHITESPACE " "
             CALL_EXPR
-              NAME_REF
+              ANY_FN
                 ANY_KW "any"
-              L_PAREN "("
-              SELECT
-                SELECT_CLAUSE
-                  SELECT_KW "select"
-                  WHITESPACE " "
-                  TARGET_LIST
-                    TARGET
-                      LITERAL
-                        INT_NUMBER "1"
-              R_PAREN ")"
+                L_PAREN "("
+                SELECT
+                  SELECT_CLAUSE
+                    SELECT_KW "select"
+                    WHITESPACE " "
+                    TARGET_LIST
+                      TARGET
+                        LITERAL
+                          INT_NUMBER "1"
+                R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   SELECT
@@ -756,44 +756,44 @@ SOURCE_FILE
             EQ "="
             WHITESPACE " "
             CALL_EXPR
-              NAME_REF
+              ANY_FN
                 ANY_KW "any"
-              L_PAREN "("
-              SELECT
-                WITH_CLAUSE
-                  WITH_KW "with"
-                  WHITESPACE " "
-                  WITH_TABLE
-                    NAME
-                      IDENT "t"
-                    WHITESPACE " "
-                    AS_KW "as"
+                L_PAREN "("
+                SELECT
+                  WITH_CLAUSE
+                    WITH_KW "with"
                     WHITESPACE " "
-                    L_PAREN "("
-                    SELECT
-                      SELECT_CLAUSE
-                        SELECT_KW "select"
-                        WHITESPACE " "
-                        TARGET_LIST
-                          TARGET
-                            LITERAL
-                              INT_NUMBER "1"
-                    R_PAREN ")"
-                WHITESPACE " "
-                SELECT_CLAUSE
-                  SELECT_KW "select"
+                    WITH_TABLE
+                      NAME
+                        IDENT "t"
+                      WHITESPACE " "
+                      AS_KW "as"
+                      WHITESPACE " "
+                      L_PAREN "("
+                      SELECT
+                        SELECT_CLAUSE
+                          SELECT_KW "select"
+                          WHITESPACE " "
+                          TARGET_LIST
+                            TARGET
+                              LITERAL
+                                INT_NUMBER "1"
+                      R_PAREN ")"
                   WHITESPACE " "
-                  TARGET_LIST
-                    TARGET
-                      STAR "*"
-                WHITESPACE " "
-                FROM_CLAUSE
-                  FROM_KW "from"
+                  SELECT_CLAUSE
+                    SELECT_KW "select"
+                    WHITESPACE " "
+                    TARGET_LIST
+                      TARGET
+                        STAR "*"
                   WHITESPACE " "
-                  FROM_ITEM
-                    NAME_REF
-                      IDENT "t"
-              R_PAREN ")"
+                  FROM_CLAUSE
+                    FROM_KW "from"
+                    WHITESPACE " "
+                    FROM_ITEM
+                      NAME_REF
+                        IDENT "t"
+                R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   SELECT
@@ -809,26 +809,26 @@ SOURCE_FILE
             EQ "="
             WHITESPACE " "
             CALL_EXPR
-              NAME_REF
+              ANY_FN
                 ANY_KW "any"
-              L_PAREN "("
-              VALUES
-                VALUES_KW "values"
-                WHITESPACE " "
-                ROW_LIST
-                  ROW
-                    L_PAREN "("
-                    LITERAL
-                      INT_NUMBER "1"
-                    R_PAREN ")"
-                  COMMA ","
+                L_PAREN "("
+                VALUES
+                  VALUES_KW "values"
                   WHITESPACE " "
-                  ROW
-                    L_PAREN "("
-                    LITERAL
-                      INT_NUMBER "3"
-                    R_PAREN ")"
-              R_PAREN ")"
+                  ROW_LIST
+                    ROW
+                      L_PAREN "("
+                      LITERAL
+                        INT_NUMBER "1"
+                      R_PAREN ")"
+                    COMMA ","
+                    WHITESPACE " "
+                    ROW
+                      L_PAREN "("
+                      LITERAL
+                        INT_NUMBER "3"
+                      R_PAREN ")"
+                R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- some"
@@ -846,18 +846,18 @@ SOURCE_FILE
             R_ANGLE ">"
             WHITESPACE " "
             CALL_EXPR
-              NAME_REF
+              SOME_FN
                 SOME_KW "some"
-              L_PAREN "("
-              SELECT
-                SELECT_CLAUSE
-                  SELECT_KW "select"
-                  WHITESPACE " "
-                  TARGET_LIST
-                    TARGET
-                      LITERAL
-                        INT_NUMBER "1"
-              R_PAREN ")"
+                L_PAREN "("
+                SELECT
+                  SELECT_CLAUSE
+                    SELECT_KW "select"
+                    WHITESPACE " "
+                    TARGET_LIST
+                      TARGET
+                        LITERAL
+                          INT_NUMBER "1"
+                R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- all"
@@ -875,18 +875,95 @@ SOURCE_FILE
             EQ "="
             WHITESPACE " "
             CALL_EXPR
-              NAME_REF
+              ALL_FN
                 ALL_KW "all"
-              L_PAREN "("
-              SELECT
-                SELECT_CLAUSE
-                  SELECT_KW "select"
-                  WHITESPACE " "
-                  TARGET_LIST
-                    TARGET
-                      LITERAL
-                        INT_NUMBER "1"
-              R_PAREN ")"
+                L_PAREN "("
+                SELECT
+                  SELECT_CLAUSE
+                    SELECT_KW "select"
+                    WHITESPACE " "
+                    TARGET_LIST
+                      TARGET
+                        LITERAL
+                          INT_NUMBER "1"
+                R_PAREN ")"
+  SEMICOLON ";"
+  WHITESPACE "\n\n"
+  COMMENT "-- some/all/any with expr"
+  WHITESPACE "\n"
+  SELECT
+    SELECT_CLAUSE
+      SELECT_KW "select"
+      WHITESPACE " "
+      TARGET_LIST
+        TARGET
+          BIN_EXPR
+            LITERAL
+              INT_NUMBER "1"
+            WHITESPACE " "
+            EQ "="
+            WHITESPACE " "
+            CALL_EXPR
+              ALL_FN
+                ALL_KW "all"
+                L_PAREN "("
+                ARRAY_EXPR
+                  ARRAY_KW "array"
+                  L_BRACK "["
+                  LITERAL
+                    INT_NUMBER "1"
+                  R_BRACK "]"
+                R_PAREN ")"
+  SEMICOLON ";"
+  WHITESPACE "\n"
+  SELECT
+    SELECT_CLAUSE
+      SELECT_KW "select"
+      WHITESPACE " "
+      TARGET_LIST
+        TARGET
+          BIN_EXPR
+            LITERAL
+              INT_NUMBER "1"
+            WHITESPACE " "
+            EQ "="
+            WHITESPACE " "
+            CALL_EXPR
+              SOME_FN
+                SOME_KW "some"
+                L_PAREN "("
+                ARRAY_EXPR
+                  ARRAY_KW "array"
+                  L_BRACK "["
+                  LITERAL
+                    INT_NUMBER "1"
+                  R_BRACK "]"
+                R_PAREN ")"
+  SEMICOLON ";"
+  WHITESPACE "\n"
+  SELECT
+    SELECT_CLAUSE
+      SELECT_KW "select"
+      WHITESPACE " "
+      TARGET_LIST
+        TARGET
+          BIN_EXPR
+            LITERAL
+              INT_NUMBER "1"
+            WHITESPACE " "
+            EQ "="
+            WHITESPACE " "
+            CALL_EXPR
+              ANY_FN
+                ANY_KW "any"
+                L_PAREN "("
+                ARRAY_EXPR
+                  ARRAY_KW "array"
+                  L_BRACK "["
+                  LITERAL
+                    INT_NUMBER "1"
+                  R_BRACK "]"
+                R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- all with array"
@@ -921,24 +998,24 @@ SOURCE_FILE
             EQ "="
             WHITESPACE " "
             CALL_EXPR
-              NAME_REF
+              ALL_FN
                 ALL_KW "all"
-              L_PAREN "("
-              ARRAY_EXPR
-                ARRAY_KW "array"
-                L_BRACK "["
-                LITERAL
-                  STRING "'a'"
-                COMMA ","
-                WHITESPACE " "
-                LITERAL
-                  STRING "'b'"
-                COMMA ","
-                WHITESPACE " "
-                LITERAL
-                  STRING "'c'"
-                R_BRACK "]"
-              R_PAREN ")"
+                L_PAREN "("
+                ARRAY_EXPR
+                  ARRAY_KW "array"
+                  L_BRACK "["
+                  LITERAL
+                    STRING "'a'"
+                  COMMA ","
+                  WHITESPACE " "
+                  LITERAL
+                    STRING "'b'"
+                  COMMA ","
+                  WHITESPACE " "
+                  LITERAL
+                    STRING "'c'"
+                  R_BRACK "]"
+                R_PAREN ")"
           R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
@@ -969,12 +1046,12 @@ SOURCE_FILE
         EQ "="
         WHITESPACE " "
         CALL_EXPR
-          NAME_REF
+          SOME_FN
             SOME_KW "some"
-          L_PAREN "("
-          NAME_REF
-            IDENT "c"
-          R_PAREN ")"
+            L_PAREN "("
+            NAME_REF
+              IDENT "c"
+            R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- any_values"
@@ -992,45 +1069,45 @@ SOURCE_FILE
             EQ "="
             WHITESPACE " "
             CALL_EXPR
-              NAME_REF
+              ANY_FN
                 ANY_KW "any"
-              L_PAREN "("
-              VALUES
-                VALUES_KW "values"
-                WHITESPACE " "
-                ROW_LIST
-                  ROW
-                    L_PAREN "("
-                    LITERAL
-                      INT_NUMBER "1"
-                    COMMA ","
-                    WHITESPACE " "
-                    LITERAL
-                      INT_NUMBER "2"
-                    R_PAREN ")"
-                  COMMA ","
+                L_PAREN "("
+                VALUES
+                  VALUES_KW "values"
                   WHITESPACE " "
-                  ROW
-                    L_PAREN "("
-                    NAME_REF
-                      IDENT "b"
+                  ROW_LIST
+                    ROW
+                      L_PAREN "("
+                      LITERAL
+                        INT_NUMBER "1"
+                      COMMA ","
+                      WHITESPACE " "
+                      LITERAL
+                        INT_NUMBER "2"
+                      R_PAREN ")"
                     COMMA ","
                     WHITESPACE " "
-                    LITERAL
-                      INT_NUMBER "3"
-                    R_PAREN ")"
-                  COMMA ","
-                  WHITESPACE " "
-                  ROW
-                    L_PAREN "("
-                    NAME_REF
-                      IDENT "c"
+                    ROW
+                      L_PAREN "("
+                      NAME_REF
+                        IDENT "b"
+                      COMMA ","
+                      WHITESPACE " "
+                      LITERAL
+                        INT_NUMBER "3"
+                      R_PAREN ")"
                     COMMA ","
                     WHITESPACE " "
-                    NAME_REF
-                      IDENT "d"
-                    R_PAREN ")"
-              R_PAREN ")"
+                    ROW
+                      L_PAREN "("
+                      NAME_REF
+                        IDENT "c"
+                      COMMA ","
+                      WHITESPACE " "
+                      NAME_REF
+                        IDENT "d"
+                      R_PAREN ")"
+                R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- field_exprs"
@@ -1625,33 +1702,34 @@ SOURCE_FILE
                 IDENT "c"
             R_PAREN ")"
         WHITESPACE " "
-        TABLESAMPLE_KW "tablesample"
-        WHITESPACE " "
-        CALL_EXPR
-          NAME_REF
-            IDENT "sample_method"
+        TABLESAMPLE_CLAUSE
+          TABLESAMPLE_KW "tablesample"
           WHITESPACE " "
-          ARG_LIST
-            L_PAREN "("
-            LITERAL
-              INT_NUMBER "10"
-            COMMA ","
+          CALL_EXPR
+            NAME_REF
+              IDENT "sample_method"
             WHITESPACE " "
-            LITERAL
-              INT_NUMBER "23"
-            COMMA ","
+            ARG_LIST
+              L_PAREN "("
+              LITERAL
+                INT_NUMBER "10"
+              COMMA ","
+              WHITESPACE " "
+              LITERAL
+                INT_NUMBER "23"
+              COMMA ","
+              WHITESPACE " "
+              LITERAL
+                INT_NUMBER "50"
+              R_PAREN ")"
+          WHITESPACE " "
+          REPEATABLE_CLAUSE
+            REPEATABLE_KW "repeatable"
             WHITESPACE " "
+            L_PAREN "("
             LITERAL
-              INT_NUMBER "50"
+              INT_NUMBER "42"
             R_PAREN ")"
-        WHITESPACE " "
-        REPEATABLE_KW "repeatable"
-        WHITESPACE " "
-        PAREN_EXPR
-          L_PAREN "("
-          LITERAL
-            INT_NUMBER "42"
-          R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   COMMENT "-- from select stmt"
diff --git a/crates/squawk_parser/tests/snapshots/tests__select_xml_ok.snap b/crates/squawk_parser/tests/snapshots/tests__select_xml_ok.snap
new file mode 100644
index 00000000..e78f7327
--- /dev/null
+++ b/crates/squawk_parser/tests/snapshots/tests__select_xml_ok.snap
@@ -0,0 +1,203 @@
+---
+source: crates/squawk_parser/tests/tests.rs
+input_file: crates/squawk_parser/tests/data/ok/select_xml.sql
+---
+SOURCE_FILE
+  COMMENT "-- xmltable"
+  WHITESPACE "\n"
+  SELECT
+    SELECT_CLAUSE
+      SELECT_KW "select"
+      WHITESPACE " "
+      TARGET_LIST
+        TARGET
+          STAR "*"
+    WHITESPACE "\n"
+    FROM_CLAUSE
+      FROM_KW "from"
+      WHITESPACE " "
+      FROM_ITEM
+        XMLTABLE_KW "xmltable"
+        L_PAREN "("
+        WHITESPACE "\n    "
+        XMLNAMESPACES_KW "xmlnamespaces"
+        XML_NAMESPACE_LIST
+          L_PAREN "("
+          XML_NAMESPACE
+            LITERAL
+              STRING "'http://example.com/books'"
+            WHITESPACE " "
+            AS_KW "as"
+            WHITESPACE " "
+            NAME
+              IDENT "bk"
+          R_PAREN ")"
+        COMMA ","
+        WHITESPACE "\n    "
+        XML_ROW_PASSING_CLAUSE
+          LITERAL
+            STRING "'/bk:library/bk:book'"
+          WHITESPACE "\n    "
+          PASSING_KW "passing"
+          WHITESPACE " "
+          CALL_EXPR
+            XML_PARSE_FN
+              XMLPARSE_KW "xmlparse"
+              L_PAREN "("
+              DOCUMENT_KW "document"
+              WHITESPACE " "
+              LITERAL
+                STRING "'<library xmlns=\"http://example.com/books\">\n               <book id=\"1\">\n                 <title>the great gatsby</title>\n                 <author>f. scott fitzgerald</author>\n                 <year>1925</year>\n                 <price>12.99</price>\n               </book>\n               <book id=\"2\">\n                 <title>1984</title>\n                 <author>george orwell</author>\n                 <year>1949</year>\n                 <price>14.99</price>\n               </book>\n               <book id=\"3\">\n                 <title>to kill a mockingbird</title>\n                 <author>harper lee</author>\n                 <year>1960</year>\n                 <price>13.99</price>\n               </book>\n             </library>'"
+              R_PAREN ")"
+        WHITESPACE "\n    "
+        XML_TABLE_COLUMN_LIST
+          COLUMNS_KW "columns"
+          WHITESPACE "\n        "
+          XML_TABLE_COLUMN
+            NAME
+              IDENT "row_num"
+            WHITESPACE " "
+            FOR_KW "for"
+            WHITESPACE " "
+            ORDINALITY_KW "ordinality"
+          COMMA ","
+          WHITESPACE "\n        "
+          XML_TABLE_COLUMN
+            NAME
+              IDENT "book_id"
+            WHITESPACE " "
+            PATH_TYPE
+              PATH
+                PATH_SEGMENT
+                  NAME_REF
+                    INTEGER_KW "integer"
+            WHITESPACE " "
+            XML_COLUMN_OPTION_LIST
+              XML_COLUMN_OPTION
+                PATH_KW "path"
+                WHITESPACE " "
+                LITERAL
+                  STRING "'@id'"
+          COMMA ","
+          WHITESPACE "\n        "
+          XML_TABLE_COLUMN
+            NAME
+              IDENT "title"
+            WHITESPACE " "
+            PATH_TYPE
+              PATH
+                PATH_SEGMENT
+                  NAME_REF
+                    TEXT_KW "text"
+            WHITESPACE " "
+            XML_COLUMN_OPTION_LIST
+              XML_COLUMN_OPTION
+                PATH_KW "path"
+                WHITESPACE " "
+                LITERAL
+                  STRING "'bk:title'"
+          COMMA ","
+          WHITESPACE "\n        "
+          XML_TABLE_COLUMN
+            NAME
+              IDENT "author"
+            WHITESPACE " "
+            PATH_TYPE
+              PATH
+                PATH_SEGMENT
+                  NAME_REF
+                    TEXT_KW "text"
+            WHITESPACE " "
+            XML_COLUMN_OPTION_LIST
+              XML_COLUMN_OPTION
+                PATH_KW "path"
+                WHITESPACE " "
+                LITERAL
+                  STRING "'bk:author'"
+          COMMA ","
+          WHITESPACE "\n        "
+          XML_TABLE_COLUMN
+            NAME
+              YEAR_KW "year"
+            WHITESPACE " "
+            PATH_TYPE
+              PATH
+                PATH_SEGMENT
+                  NAME_REF
+                    INTEGER_KW "integer"
+            WHITESPACE " "
+            XML_COLUMN_OPTION_LIST
+              XML_COLUMN_OPTION
+                PATH_KW "path"
+                WHITESPACE " "
+                LITERAL
+                  STRING "'bk:year'"
+          COMMA ","
+          WHITESPACE "\n        "
+          XML_TABLE_COLUMN
+            NAME
+              IDENT "price"
+            WHITESPACE " "
+            PATH_TYPE
+              PATH
+                PATH_SEGMENT
+                  NAME_REF
+                    NUMERIC_KW "numeric"
+              ARG_LIST
+                L_PAREN "("
+                ARG
+                  LITERAL
+                    INT_NUMBER "5"
+                COMMA ","
+                ARG
+                  LITERAL
+                    INT_NUMBER "2"
+                R_PAREN ")"
+            WHITESPACE " "
+            XML_COLUMN_OPTION_LIST
+              XML_COLUMN_OPTION
+                PATH_KW "path"
+                WHITESPACE " "
+                LITERAL
+                  STRING "'bk:price'"
+              WHITESPACE " "
+              XML_COLUMN_OPTION
+                DEFAULT_KW "default"
+                WHITESPACE " "
+                LITERAL
+                  FLOAT_NUMBER "0.00"
+          COMMA ","
+          WHITESPACE "\n        "
+          XML_TABLE_COLUMN
+            NAME
+              IDENT "discount"
+            WHITESPACE " "
+            PATH_TYPE
+              PATH
+                PATH_SEGMENT
+                  NAME_REF
+                    NUMERIC_KW "numeric"
+              ARG_LIST
+                L_PAREN "("
+                ARG
+                  LITERAL
+                    INT_NUMBER "5"
+                COMMA ","
+                ARG
+                  LITERAL
+                    INT_NUMBER "2"
+                R_PAREN ")"
+            WHITESPACE " "
+            XML_COLUMN_OPTION_LIST
+              XML_COLUMN_OPTION
+                DEFAULT_KW "default"
+                WHITESPACE " "
+                LITERAL
+                  FLOAT_NUMBER "0.00"
+              WHITESPACE " "
+              XML_COLUMN_OPTION
+                NULL_KW "null"
+        WHITESPACE "\n"
+        R_PAREN ")"
+  SEMICOLON ";"
+  WHITESPACE "\n"
diff --git a/crates/squawk_parser/tests/tests.rs b/crates/squawk_parser/tests/tests.rs
index 0394aab9..8b48511d 100644
--- a/crates/squawk_parser/tests/tests.rs
+++ b/crates/squawk_parser/tests/tests.rs
@@ -100,6 +100,11 @@ fn regression_suite(fixture: Fixture<&str>) {
     }, {
       assert_snapshot!(snapshot_name, errors.join(""));
     });
+
+    assert!(
+        errors.is_empty(),
+        "tests defined in the regression suite can't have parser errors."
+    );
 }
 
 fn parse_text(text: &str) -> (String, Vec<std::string::String>) {
diff --git a/crates/squawk_syntax/src/ast/generated/nodes.rs b/crates/squawk_syntax/src/ast/generated/nodes.rs
index cd749f74..e0f0aec0 100644
--- a/crates/squawk_syntax/src/ast/generated/nodes.rs
+++ b/crates/squawk_syntax/src/ast/generated/nodes.rs
@@ -150,6 +150,33 @@ impl Alias {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AllFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl AllFn {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn select_variant(&self) -> Option<SelectVariant> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AlterAggregate {
     pub(crate) syntax: SyntaxNode,
@@ -1682,6 +1709,33 @@ impl Analyze {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AnyFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl AnyFn {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn select_variant(&self) -> Option<SelectVariant> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn any_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ANY_KW)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Arg {
     pub(crate) syntax: SyntaxNode,
@@ -2074,26 +2128,130 @@ pub struct CallExpr {
     pub(crate) syntax: SyntaxNode,
 }
 impl CallExpr {
+    #[inline]
+    pub fn all_fn(&self) -> Option<AllFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn any_fn(&self) -> Option<AnyFn> {
+        support::child(&self.syntax)
+    }
     #[inline]
     pub fn arg_list(&self) -> Option<ArgList> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn exists_fn(&self) -> Option<ExistsFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn extract_fn(&self) -> Option<ExtractFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn filter_clause(&self) -> Option<FilterClause> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn json_array_agg_fn(&self) -> Option<JsonArrayAggFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_array_fn(&self) -> Option<JsonArrayFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_exists_fn(&self) -> Option<JsonExistsFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_fn(&self) -> Option<JsonFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_object_agg_fn(&self) -> Option<JsonObjectAggFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_object_fn(&self) -> Option<JsonObjectFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_query_fn(&self) -> Option<JsonQueryFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_scalar_fn(&self) -> Option<JsonScalarFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_serialize_fn(&self) -> Option<JsonSerializeFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_value_fn(&self) -> Option<JsonValueFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn over_clause(&self) -> Option<OverClause> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn overlay_fn(&self) -> Option<OverlayFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn position_fn(&self) -> Option<PositionFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn some_fn(&self) -> Option<SomeFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn substring_fn(&self) -> Option<SubstringFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn trim_fn(&self) -> Option<TrimFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn within_clause(&self) -> Option<WithinClause> {
         support::child(&self.syntax)
     }
+    #[inline]
+    pub fn xml_element_fn(&self) -> Option<XmlElementFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_exists_fn(&self) -> Option<XmlExistsFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_forest_fn(&self) -> Option<XmlForestFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_parse_fn(&self) -> Option<XmlParseFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_pi_fn(&self) -> Option<XmlPiFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_root_fn(&self) -> Option<XmlRootFn> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_serialize_fn(&self) -> Option<XmlSerializeFn> {
+        support::child(&self.syntax)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2144,6 +2302,10 @@ impl CastExpr {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn literal(&self) -> Option<Literal> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn ty(&self) -> Option<Type> {
         support::child(&self.syntax)
     }
@@ -2163,6 +2325,10 @@ impl CastExpr {
     pub fn cast_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::CAST_KW)
     }
+    #[inline]
+    pub fn treat_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TREAT_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2697,6 +2863,10 @@ impl ConstraintExclusion {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn op(&self) -> Option<Op> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn with_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::WITH_KW)
     }
@@ -2766,29 +2936,6 @@ impl ConstraintIndexTablespace {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstraintWhereClause {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ConstraintWhereClause {
-    #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
-    }
-    #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
-    }
-    #[inline]
-    pub fn where_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WHERE_KW)
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Copy {
     pub(crate) syntax: SyntaxNode,
@@ -3237,6 +3384,14 @@ pub struct CreateForeignDataWrapper {
     pub(crate) syntax: SyntaxNode,
 }
 impl CreateForeignDataWrapper {
+    #[inline]
+    pub fn alter_option_list(&self) -> Option<AlterOptionList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn fdw_option_list(&self) -> Option<FdwOptionList> {
+        support::child(&self.syntax)
+    }
     #[inline]
     pub fn name(&self) -> Option<Name> {
         support::child(&self.syntax)
@@ -3264,15 +3419,31 @@ pub struct CreateForeignTable {
     pub(crate) syntax: SyntaxNode,
 }
 impl CreateForeignTable {
+    #[inline]
+    pub fn alter_option_list(&self) -> Option<AlterOptionList> {
+        support::child(&self.syntax)
+    }
     #[inline]
     pub fn if_not_exists(&self) -> Option<IfNotExists> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn inherits(&self) -> Option<Inherits> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn partition_of(&self) -> Option<PartitionOf> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn partition_type(&self) -> Option<PartitionType> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
@@ -3437,13 +3608,41 @@ impl CreateLanguage {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn or_replace(&self) -> Option<OrReplace> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn path(&self) -> Option<Path> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn create_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::CREATE_KW)
     }
     #[inline]
+    pub fn handler_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::HANDLER_KW)
+    }
+    #[inline]
+    pub fn inline_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INLINE_KW)
+    }
+    #[inline]
     pub fn language_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
     }
+    #[inline]
+    pub fn procedural_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PROCEDURAL_KW)
+    }
+    #[inline]
+    pub fn trusted_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRUSTED_KW)
+    }
+    #[inline]
+    pub fn validator_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VALIDATOR_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -3628,68 +3827,156 @@ pub struct CreatePolicy {
 }
 impl CreatePolicy {
     #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn on_table(&self) -> Option<OnTable> {
+    pub fn name(&self) -> Option<Name> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn create_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CREATE_KW)
-    }
-    #[inline]
-    pub fn policy_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::POLICY_KW)
+    pub fn on_table(&self) -> Option<OnTable> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct CreateProcedure {
-    pub(crate) syntax: SyntaxNode,
-}
-impl CreateProcedure {
     #[inline]
-    pub fn option_list(&self) -> Option<FuncOptionList> {
+    pub fn role_list(&self) -> Option<RoleList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn param_list(&self) -> Option<ParamList> {
-        support::child(&self.syntax)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn create_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CREATE_KW)
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
     }
     #[inline]
-    pub fn procedure_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PROCEDURE_KW)
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct CreatePublication {
-    pub(crate) syntax: SyntaxNode,
-}
-impl CreatePublication {
     #[inline]
-    pub fn name(&self) -> Option<Name> {
-        support::child(&self.syntax)
+    pub fn check_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CHECK_KW)
     }
     #[inline]
     pub fn create_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::CREATE_KW)
     }
     #[inline]
-    pub fn publication_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PUBLICATION_KW)
+    pub fn delete_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DELETE_KW)
     }
-}
+    #[inline]
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    }
+    #[inline]
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
+    }
+    #[inline]
+    pub fn insert_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INSERT_KW)
+    }
+    #[inline]
+    pub fn policy_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::POLICY_KW)
+    }
+    #[inline]
+    pub fn select_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SELECT_KW)
+    }
+    #[inline]
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
+    }
+    #[inline]
+    pub fn update_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UPDATE_KW)
+    }
+    #[inline]
+    pub fn using_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::USING_KW)
+    }
+    #[inline]
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct CreateProcedure {
+    pub(crate) syntax: SyntaxNode,
+}
+impl CreateProcedure {
+    #[inline]
+    pub fn option_list(&self) -> Option<FuncOptionList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn or_replace(&self) -> Option<OrReplace> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn param_list(&self) -> Option<ParamList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn path(&self) -> Option<Path> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn create_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CREATE_KW)
+    }
+    #[inline]
+    pub fn procedure_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PROCEDURE_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct CreatePublication {
+    pub(crate) syntax: SyntaxNode,
+}
+impl CreatePublication {
+    #[inline]
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn publication_objects(&self) -> AstChildren<PublicationObject> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn with_params(&self) -> Option<WithParams> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    }
+    #[inline]
+    pub fn create_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CREATE_KW)
+    }
+    #[inline]
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    }
+    #[inline]
+    pub fn publication_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PUBLICATION_KW)
+    }
+    #[inline]
+    pub fn tables_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLES_KW)
+    }
+}
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CreateRole {
@@ -3701,6 +3988,10 @@ impl CreateRole {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn role_option_list(&self) -> Option<RoleOptionList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn create_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::CREATE_KW)
     }
@@ -3880,18 +4171,54 @@ pub struct CreateServer {
     pub(crate) syntax: SyntaxNode,
 }
 impl CreateServer {
+    #[inline]
+    pub fn alter_option_list(&self) -> Option<AlterOptionList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn if_not_exists(&self) -> Option<IfNotExists> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn literal(&self) -> Option<Literal> {
+        support::child(&self.syntax)
+    }
     #[inline]
     pub fn name(&self) -> Option<Name> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn create_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::CREATE_KW)
     }
     #[inline]
+    pub fn data_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DATA_KW)
+    }
+    #[inline]
+    pub fn foreign_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
+    }
+    #[inline]
     pub fn server_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::SERVER_KW)
     }
+    #[inline]
+    pub fn type_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TYPE_KW)
+    }
+    #[inline]
+    pub fn version_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VERSION_KW)
+    }
+    #[inline]
+    pub fn wrapper_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WRAPPER_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -3930,15 +4257,35 @@ pub struct CreateSubscription {
     pub(crate) syntax: SyntaxNode,
 }
 impl CreateSubscription {
+    #[inline]
+    pub fn literal(&self) -> Option<Literal> {
+        support::child(&self.syntax)
+    }
     #[inline]
     pub fn name(&self) -> Option<Name> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn name_refs(&self) -> AstChildren<NameRef> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn with_params(&self) -> Option<WithParams> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn connection_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONNECTION_KW)
+    }
+    #[inline]
     pub fn create_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::CREATE_KW)
     }
     #[inline]
+    pub fn publication_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PUBLICATION_KW)
+    }
+    #[inline]
     pub fn subscription_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW)
     }
@@ -4002,9 +4349,29 @@ impl CreateTable {
         support::token(&self.syntax, SyntaxKind::CREATE_KW)
     }
     #[inline]
+    pub fn global_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::GLOBAL_KW)
+    }
+    #[inline]
+    pub fn local_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LOCAL_KW)
+    }
+    #[inline]
     pub fn table_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::TABLE_KW)
     }
+    #[inline]
+    pub fn temp_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TEMP_KW)
+    }
+    #[inline]
+    pub fn temporary_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TEMPORARY_KW)
+    }
+    #[inline]
+    pub fn unlogged_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UNLOGGED_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -4049,6 +4416,10 @@ impl CreateTableAs {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn without_oids(&self) -> Option<WithoutOids> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn as_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::AS_KW)
     }
@@ -4057,9 +4428,29 @@ impl CreateTableAs {
         support::token(&self.syntax, SyntaxKind::CREATE_KW)
     }
     #[inline]
+    pub fn global_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::GLOBAL_KW)
+    }
+    #[inline]
+    pub fn local_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LOCAL_KW)
+    }
+    #[inline]
     pub fn table_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::TABLE_KW)
     }
+    #[inline]
+    pub fn temp_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TEMP_KW)
+    }
+    #[inline]
+    pub fn temporary_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TEMPORARY_KW)
+    }
+    #[inline]
+    pub fn unlogged_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UNLOGGED_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -4436,6 +4827,10 @@ impl CreateUser {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn role_option_list(&self) -> Option<RoleOptionList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn create_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::CREATE_KW)
     }
@@ -4455,6 +4850,10 @@ impl CreateUserMapping {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn if_not_exists(&self) -> Option<IfNotExists> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
@@ -4538,6 +4937,14 @@ impl CreateView {
         support::token(&self.syntax, SyntaxKind::RECURSIVE_KW)
     }
     #[inline]
+    pub fn temp_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TEMP_KW)
+    }
+    #[inline]
+    pub fn temporary_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TEMPORARY_KW)
+    }
+    #[inline]
     pub fn view_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::VIEW_KW)
     }
@@ -5334,8 +5741,12 @@ impl DropForeignDataWrapper {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn name_refs(&self) -> AstChildren<NameRef> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn cascade_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CASCADE_KW)
     }
     #[inline]
     pub fn data_token(&self) -> Option<SyntaxToken> {
@@ -5350,6 +5761,10 @@ impl DropForeignDataWrapper {
         support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
     }
     #[inline]
+    pub fn restrict_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
+    }
+    #[inline]
     pub fn wrapper_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::WRAPPER_KW)
     }
@@ -5369,6 +5784,10 @@ impl DropForeignTable {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn cascade_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CASCADE_KW)
+    }
+    #[inline]
     pub fn drop_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::DROP_KW)
     }
@@ -5377,6 +5796,10 @@ impl DropForeignTable {
         support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
     }
     #[inline]
+    pub fn restrict_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
+    }
+    #[inline]
     pub fn table_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::TABLE_KW)
     }
@@ -5396,6 +5819,10 @@ impl DropFunction {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn cascade_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CASCADE_KW)
+    }
+    #[inline]
     pub fn drop_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::DROP_KW)
     }
@@ -5403,6 +5830,10 @@ impl DropFunction {
     pub fn function_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
     }
+    #[inline]
+    pub fn restrict_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -5488,6 +5919,10 @@ impl DropLanguage {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn cascade_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CASCADE_KW)
+    }
+    #[inline]
     pub fn drop_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::DROP_KW)
     }
@@ -5495,8 +5930,16 @@ impl DropLanguage {
     pub fn language_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
     }
-}
-
+    #[inline]
+    pub fn procedural_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PROCEDURAL_KW)
+    }
+    #[inline]
+    pub fn restrict_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DropMaterializedView {
     pub(crate) syntax: SyntaxNode,
@@ -5714,11 +6157,19 @@ pub struct DropOwned {
     pub(crate) syntax: SyntaxNode,
 }
 impl DropOwned {
+    #[inline]
+    pub fn role_list(&self) -> Option<RoleList> {
+        support::child(&self.syntax)
+    }
     #[inline]
     pub fn by_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::BY_KW)
     }
     #[inline]
+    pub fn cascade_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CASCADE_KW)
+    }
+    #[inline]
     pub fn drop_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::DROP_KW)
     }
@@ -5726,6 +6177,10 @@ impl DropOwned {
     pub fn owned_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::OWNED_KW)
     }
+    #[inline]
+    pub fn restrict_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -6647,11 +7102,11 @@ impl ExcludeConstraint {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn constraint_where_clause(&self) -> Option<ConstraintWhereClause> {
+    pub fn name(&self) -> Option<Name> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn where_condition_clause(&self) -> Option<WhereConditionClause> {
         support::child(&self.syntax)
     }
     #[inline]
@@ -6683,6 +7138,29 @@ impl Execute {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExistsFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ExistsFn {
+    #[inline]
+    pub fn select_variant(&self) -> Option<SelectVariant> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn exists_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EXISTS_KW)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Explain {
     pub(crate) syntax: SyntaxNode,
@@ -6698,6 +7176,21 @@ impl Explain {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprAsName {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ExprAsName {
+    #[inline]
+    pub fn as_name(&self) -> Option<AsName> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExprType {
     pub(crate) syntax: SyntaxNode,
@@ -6709,6 +7202,65 @@ impl ExprType {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExtractFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ExtractFn {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn day_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DAY_KW)
+    }
+    #[inline]
+    pub fn extract_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EXTRACT_KW)
+    }
+    #[inline]
+    pub fn from_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FROM_KW)
+    }
+    #[inline]
+    pub fn hour_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::HOUR_KW)
+    }
+    #[inline]
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
+    }
+    #[inline]
+    pub fn minute_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MINUTE_KW)
+    }
+    #[inline]
+    pub fn month_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MONTH_KW)
+    }
+    #[inline]
+    pub fn second_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SECOND_KW)
+    }
+    #[inline]
+    pub fn string_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STRING_KW)
+    }
+    #[inline]
+    pub fn year_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::YEAR_KW)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FatArrow {
     pub(crate) syntax: SyntaxNode,
@@ -7011,10 +7563,18 @@ impl FromItem {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn cast_expr(&self) -> Option<CastExpr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn field_expr(&self) -> Option<FieldExpr> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn json_table(&self) -> Option<JsonTable> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
@@ -7023,6 +7583,14 @@ impl FromItem {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn tablesample_clause(&self) -> Option<TablesampleClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_table(&self) -> Option<XmlTable> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn l_paren_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
@@ -7043,9 +7611,17 @@ impl FromItem {
         support::token(&self.syntax, SyntaxKind::ONLY_KW)
     }
     #[inline]
+    pub fn ordinality_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ORDINALITY_KW)
+    }
+    #[inline]
     pub fn rows_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::ROWS_KW)
     }
+    #[inline]
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -8263,6 +8839,87 @@ impl JoinUsingClause {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct JsonArrayAggFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl JsonArrayAggFn {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_null_clause(&self) -> Option<JsonNullClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_returning_clause(&self) -> Option<JsonReturningClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_select_formats(&self) -> AstChildren<JsonSelectFormat> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn json_arrayagg_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_ARRAYAGG_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct JsonArrayFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl JsonArrayFn {
+    #[inline]
+    pub fn json_expr_formats(&self) -> AstChildren<JsonExprFormat> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn json_null_clause(&self) -> Option<JsonNullClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_returning_clause(&self) -> Option<JsonReturningClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_select_formats(&self) -> AstChildren<JsonSelectFormat> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn json_array_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_ARRAY_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct JsonBehaviorClause {
+    pub(crate) syntax: SyntaxNode,
+}
+impl JsonBehaviorClause {
+    #[inline]
+    pub fn json_behavior(&self) -> Option<JsonBehavior> {
+        support::child(&self.syntax)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct JsonBehaviorDefault {
     pub(crate) syntax: SyntaxNode,
@@ -8364,244 +9021,238 @@ impl JsonBehaviorUnknown {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonFormatClause {
+pub struct JsonEncodingClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonFormatClause {
+impl JsonEncodingClause {
     #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
     #[inline]
     pub fn encoding_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::ENCODING_KW)
     }
-    #[inline]
-    pub fn format_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FORMAT_KW)
-    }
-    #[inline]
-    pub fn json_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::JSON_KW)
-    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonKeyValue {
+pub struct JsonExistsFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonKeyValue {
+impl JsonExistsFn {
     #[inline]
     pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn json_value_expr(&self) -> Option<JsonValueExpr> {
+    pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn colon_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COLON)
+    pub fn json_on_error_clause(&self) -> Option<JsonOnErrorClause> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonKeysUniqueClause {
-    pub(crate) syntax: SyntaxNode,
-}
-impl JsonKeysUniqueClause {
     #[inline]
-    pub fn keys_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::KEYS_KW)
+    pub fn json_passing_clause(&self) -> Option<JsonPassingClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn unique_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::UNIQUE_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn without_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
+    pub fn comma_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMA)
+    }
+    #[inline]
+    pub fn json_exists_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_EXISTS_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonNullClause {
+pub struct JsonExprFormat {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonNullClause {
-    #[inline]
-    pub fn absent_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ABSENT_KW)
-    }
+impl JsonExprFormat {
     #[inline]
-    pub fn null_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
+        support::child(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonOnEmptyClause {
+pub struct JsonFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonOnEmptyClause {
+impl JsonFn {
     #[inline]
-    pub fn json_behavior(&self) -> Option<JsonBehavior> {
+    pub fn json_expr_format(&self) -> Option<JsonExprFormat> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn empty_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EMPTY_KW)
+    pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn json_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonOnErrorClause {
+pub struct JsonFormatClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonOnErrorClause {
+impl JsonFormatClause {
     #[inline]
-    pub fn json_behavior(&self) -> Option<JsonBehavior> {
+    pub fn json_encoding_clause(&self) -> Option<JsonEncodingClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn error_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ERROR_KW)
+    pub fn format_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FORMAT_KW)
     }
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn json_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonPassingArg {
+pub struct JsonKeyValue {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonPassingArg {
+impl JsonKeyValue {
     #[inline]
     pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn json_value_expr(&self) -> Option<JsonValueExpr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn as_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AS_KW)
+    pub fn colon_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COLON)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonPassingClause {
+pub struct JsonKeysUniqueClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonPassingClause {
-    #[inline]
-    pub fn json_passing_args(&self) -> AstChildren<JsonPassingArg> {
-        support::children(&self.syntax)
-    }
+impl JsonKeysUniqueClause {
     #[inline]
-    pub fn passing_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PASSING_KW)
+    pub fn keys_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::KEYS_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonQuotesClause {
-    pub(crate) syntax: SyntaxNode,
-}
-impl JsonQuotesClause {
     #[inline]
-    pub fn keep_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::KEEP_KW)
+    pub fn unique_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UNIQUE_KW)
     }
     #[inline]
-    pub fn omit_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OMIT_KW)
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
     }
     #[inline]
-    pub fn quotes_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::QUOTES_KW)
+    pub fn without_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonReturningClause {
+pub struct JsonNullClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonReturningClause {
+impl JsonNullClause {
     #[inline]
-    pub fn ty(&self) -> Option<Type> {
-        support::child(&self.syntax)
+    pub fn absent_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ABSENT_KW)
     }
     #[inline]
-    pub fn returning_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RETURNING_KW)
+    pub fn null_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    }
+    #[inline]
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonTableColumn {
+pub struct JsonObjectAggFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonTableColumn {
+impl JsonObjectAggFn {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
+    pub fn json_key_value(&self) -> Option<JsonKeyValue> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn ty(&self) -> Option<Type> {
+    pub fn json_null_clause(&self) -> Option<JsonNullClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn for_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    pub fn returning_clause(&self) -> Option<ReturningClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn nested_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NESTED_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn ordinality_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ORDINALITY_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn path_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PATH_KW)
+    pub fn json_objectagg_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_OBJECTAGG_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonTableColumnList {
+pub struct JsonObjectFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonTableColumnList {
+impl JsonObjectFn {
     #[inline]
-    pub fn json_table_columns(&self) -> AstChildren<JsonTableColumn> {
+    pub fn json_key_values(&self) -> AstChildren<JsonKeyValue> {
         support::children(&self.syntax)
     }
     #[inline]
+    pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_null_clause(&self) -> Option<JsonNullClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn json_returning_clause(&self) -> Option<JsonReturningClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn l_paren_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
@@ -8610,1931 +9261,1857 @@ impl JsonTableColumnList {
         support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn columns_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COLUMNS_KW)
+    pub fn json_object_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_OBJECT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonValueExpr {
+pub struct JsonOnEmptyClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonValueExpr {
+impl JsonOnEmptyClause {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
+    pub fn json_behavior(&self) -> Option<JsonBehavior> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
-        support::child(&self.syntax)
+    pub fn empty_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EMPTY_KW)
+    }
+    #[inline]
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct JsonWrapperBehaviorClause {
+pub struct JsonOnErrorClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl JsonWrapperBehaviorClause {
-    #[inline]
-    pub fn conditional_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONDITIONAL_KW)
-    }
+impl JsonOnErrorClause {
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn json_behavior(&self) -> Option<JsonBehavior> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn without_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
+    pub fn error_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ERROR_KW)
     }
     #[inline]
-    pub fn wrapper_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WRAPPER_KW)
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LanguageFuncOption {
+pub struct JsonPassingArg {
     pub(crate) syntax: SyntaxNode,
 }
-impl LanguageFuncOption {
+impl JsonPassingArg {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
-    #[inline]
-    pub fn language_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
-    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LeakproofFuncOption {
+pub struct JsonPassingClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl LeakproofFuncOption {
+impl JsonPassingClause {
     #[inline]
-    pub fn leakproof_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LEAKPROOF_KW)
+    pub fn json_passing_args(&self) -> AstChildren<JsonPassingArg> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn passing_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PASSING_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LikeClause {
+pub struct JsonPathClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl LikeClause {
-    #[inline]
-    pub fn like_options(&self) -> AstChildren<LikeOption> {
-        support::children(&self.syntax)
-    }
+impl JsonPathClause {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn like_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LIKE_KW)
+    pub fn path_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PATH_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LikeOption {
+pub struct JsonQueryFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl LikeOption {
-    #[inline]
-    pub fn all_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ALL_KW)
-    }
+impl JsonQueryFn {
     #[inline]
-    pub fn comments_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COMMENTS_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn compression_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COMPRESSION_KW)
+    pub fn json_behavior_clause(&self) -> Option<JsonBehaviorClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn constraints_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONSTRAINTS_KW)
+    pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn defaults_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULTS_KW)
+    pub fn json_passing_clause(&self) -> Option<JsonPassingClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn excluding_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EXCLUDING_KW)
+    pub fn json_quotes_clause(&self) -> Option<JsonQuotesClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn generated_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::GENERATED_KW)
+    pub fn json_returning_clause(&self) -> Option<JsonReturningClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn identity_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
+    pub fn json_wrapper_behavior_clause(&self) -> Option<JsonWrapperBehaviorClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn including_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INCLUDING_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn indexes_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INDEXES_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn statistics_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::STATISTICS_KW)
+    pub fn comma_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMA)
     }
     #[inline]
-    pub fn storage_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::STORAGE_KW)
+    pub fn json_query_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_QUERY_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LimitClause {
+pub struct JsonQuotesClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl LimitClause {
+impl JsonQuotesClause {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
+    pub fn keep_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::KEEP_KW)
     }
     #[inline]
-    pub fn all_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    pub fn omit_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OMIT_KW)
     }
     #[inline]
-    pub fn limit_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LIMIT_KW)
+    pub fn quotes_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::QUOTES_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LimitToTables {
+pub struct JsonReturningClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl LimitToTables {
+impl JsonReturningClause {
     #[inline]
-    pub fn name_refs(&self) -> AstChildren<NameRef> {
-        support::children(&self.syntax)
-    }
-    #[inline]
-    pub fn limit_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LIMIT_KW)
+    pub fn ty(&self) -> Option<Type> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn returning_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RETURNING_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Listen {
+pub struct JsonScalarFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl Listen {
+impl JsonScalarFn {
     #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn listen_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LISTEN_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn json_scalar_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_SCALAR_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Literal {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Literal {}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Load {
+pub struct JsonSelectFormat {
     pub(crate) syntax: SyntaxNode,
 }
-impl Load {
+impl JsonSelectFormat {
     #[inline]
-    pub fn literal(&self) -> Option<Literal> {
+    pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn load_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LOAD_KW)
+    pub fn select_variant(&self) -> Option<SelectVariant> {
+        support::child(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Lock {
+pub struct JsonSerializeFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl Lock {
+impl JsonSerializeFn {
     #[inline]
-    pub fn table_list(&self) -> Option<TableList> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn lock_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LOCK_KW)
+    pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn table_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLE_KW)
+    pub fn json_returning_clause(&self) -> Option<JsonReturningClause> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LockingClause {
-    pub(crate) syntax: SyntaxNode,
-}
-impl LockingClause {
     #[inline]
-    pub fn for_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Lteq {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Lteq {
     #[inline]
-    pub fn l_angle_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_ANGLE)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn eq_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EQ)
+    pub fn json_serialize_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_SERIALIZE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MatchFull {
+pub struct JsonTable {
     pub(crate) syntax: SyntaxNode,
 }
-impl MatchFull {
+impl JsonTable {
     #[inline]
-    pub fn full_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FULL_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn match_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MATCH_KW)
+    pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MatchPartial {
-    pub(crate) syntax: SyntaxNode,
-}
-impl MatchPartial {
     #[inline]
-    pub fn match_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MATCH_KW)
+    pub fn json_on_error_clause(&self) -> Option<JsonOnErrorClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn partial_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PARTIAL_KW)
+    pub fn json_passing_clause(&self) -> Option<JsonPassingClause> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MatchSimple {
-    pub(crate) syntax: SyntaxNode,
-}
-impl MatchSimple {
     #[inline]
-    pub fn match_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MATCH_KW)
+    pub fn json_table_column_list(&self) -> Option<JsonTableColumnList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn simple_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SIMPLE_KW)
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Materialized {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Materialized {
     #[inline]
-    pub fn materialized_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn comma_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMA)
+    }
+    #[inline]
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
+    }
+    #[inline]
+    pub fn json_table_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_TABLE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Merge {
+pub struct JsonTableColumn {
     pub(crate) syntax: SyntaxNode,
 }
-impl Merge {
+impl JsonTableColumn {
     #[inline]
-    pub fn alias(&self) -> Option<Alias> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn merge_when_clauses(&self) -> AstChildren<MergeWhenClause> {
-        support::children(&self.syntax)
-    }
-    #[inline]
-    pub fn relation_name(&self) -> Option<RelationName> {
+    pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn using_on_clause(&self) -> Option<UsingOnClause> {
+    pub fn json_on_empty_clause(&self) -> Option<JsonOnEmptyClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn into_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INTO_KW)
+    pub fn json_on_error_clause(&self) -> Option<JsonOnErrorClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn merge_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MERGE_KW)
+    pub fn json_path_clause(&self) -> Option<JsonPathClause> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MergeDelete {
-    pub(crate) syntax: SyntaxNode,
-}
-impl MergeDelete {
     #[inline]
-    pub fn delete_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DELETE_KW)
+    pub fn json_quotes_clause(&self) -> Option<JsonQuotesClause> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MergeDoNothing {
-    pub(crate) syntax: SyntaxNode,
-}
-impl MergeDoNothing {
     #[inline]
-    pub fn do_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DO_KW)
+    pub fn json_table_column_list(&self) -> Option<JsonTableColumnList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn nothing_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOTHING_KW)
+    pub fn json_wrapper_behavior_clause(&self) -> Option<JsonWrapperBehaviorClause> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MergeInsert {
-    pub(crate) syntax: SyntaxNode,
-}
-impl MergeInsert {
     #[inline]
-    pub fn column_list(&self) -> Option<ColumnList> {
+    pub fn name(&self) -> Option<Name> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn values(&self) -> Option<Values> {
+    pub fn ty(&self) -> Option<Type> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn default_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
     }
     #[inline]
-    pub fn insert_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INSERT_KW)
+    pub fn exists_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EXISTS_KW)
     }
     #[inline]
-    pub fn overriding_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OVERRIDING_KW)
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
     }
     #[inline]
-    pub fn system_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SYSTEM_KW)
+    pub fn nested_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NESTED_KW)
     }
     #[inline]
-    pub fn user_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::USER_KW)
+    pub fn ordinality_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ORDINALITY_KW)
     }
     #[inline]
-    pub fn values_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VALUES_KW)
+    pub fn path_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PATH_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MergeUpdate {
+pub struct JsonTableColumnList {
     pub(crate) syntax: SyntaxNode,
 }
-impl MergeUpdate {
+impl JsonTableColumnList {
     #[inline]
-    pub fn set_clause(&self) -> Option<SetClause> {
-        support::child(&self.syntax)
+    pub fn json_table_columns(&self) -> AstChildren<JsonTableColumn> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn update_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::UPDATE_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn columns_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COLUMNS_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MergeWhenMatched {
+pub struct JsonValueExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl MergeWhenMatched {
+impl JsonValueExpr {
     #[inline]
     pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn merge_action(&self) -> Option<MergeAction> {
+    pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
         support::child(&self.syntax)
     }
-    #[inline]
-    pub fn and_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AND_KW)
-    }
-    #[inline]
-    pub fn matched_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MATCHED_KW)
-    }
-    #[inline]
-    pub fn then_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::THEN_KW)
-    }
-    #[inline]
-    pub fn when_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WHEN_KW)
-    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MergeWhenNotMatchedSource {
+pub struct JsonValueFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl MergeWhenNotMatchedSource {
+impl JsonValueFn {
     #[inline]
     pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn merge_action(&self) -> Option<MergeAction> {
+    pub fn json_behavior_clause(&self) -> Option<JsonBehaviorClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn and_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AND_KW)
+    pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn by_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::BY_KW)
+    pub fn json_passing_clause(&self) -> Option<JsonPassingClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn matched_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MATCHED_KW)
+    pub fn json_returning_clause(&self) -> Option<JsonReturningClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn source_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SOURCE_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn then_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::THEN_KW)
+    pub fn comma_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMA)
     }
     #[inline]
-    pub fn when_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WHEN_KW)
+    pub fn json_value_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::JSON_VALUE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MergeWhenNotMatchedTarget {
+pub struct JsonWrapperBehaviorClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl MergeWhenNotMatchedTarget {
-    #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn merge_action(&self) -> Option<MergeAction> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn and_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AND_KW)
-    }
+impl JsonWrapperBehaviorClause {
     #[inline]
-    pub fn by_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::BY_KW)
+    pub fn array_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ARRAY_KW)
     }
     #[inline]
-    pub fn matched_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MATCHED_KW)
+    pub fn conditional_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONDITIONAL_KW)
     }
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn unconditional_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UNCONDITIONAL_KW)
     }
     #[inline]
-    pub fn target_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TARGET_KW)
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
     }
     #[inline]
-    pub fn then_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::THEN_KW)
+    pub fn without_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
     }
     #[inline]
-    pub fn when_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WHEN_KW)
+    pub fn wrapper_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WRAPPER_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Move {
+pub struct LanguageFuncOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl Move {
+impl LanguageFuncOption {
     #[inline]
     pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn from_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FROM_KW)
-    }
-    #[inline]
-    pub fn in_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IN_KW)
-    }
-    #[inline]
-    pub fn move_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MOVE_KW)
+    pub fn language_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Name {
+pub struct LeakproofFuncOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl Name {
+impl LeakproofFuncOption {
     #[inline]
-    pub fn ident_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENT)
+    pub fn leakproof_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LEAKPROOF_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NameRef {
-    pub(crate) syntax: SyntaxNode,
-}
-impl NameRef {
     #[inline]
-    pub fn ident_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENT)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NamedArg {
+pub struct LikeClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl NamedArg {
+impl LikeClause {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
+    pub fn like_options(&self) -> AstChildren<LikeOption> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn fat_arrow(&self) -> Option<FatArrow> {
+    pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn like_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LIKE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Neq {
+pub struct LikeOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl Neq {
+impl LikeOption {
     #[inline]
-    pub fn bang_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::BANG)
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
     }
     #[inline]
-    pub fn eq_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EQ)
+    pub fn comments_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMENTS_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Neqb {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Neqb {
     #[inline]
-    pub fn l_angle_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_ANGLE)
+    pub fn compression_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMPRESSION_KW)
     }
     #[inline]
-    pub fn r_angle_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_ANGLE)
+    pub fn constraints_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONSTRAINTS_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NoAction {
-    pub(crate) syntax: SyntaxNode,
-}
-impl NoAction {
     #[inline]
-    pub fn action_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ACTION_KW)
+    pub fn defaults_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULTS_KW)
     }
     #[inline]
-    pub fn no_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NO_KW)
+    pub fn excluding_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EXCLUDING_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NoDependsOnExtension {
-    pub(crate) syntax: SyntaxNode,
-}
-impl NoDependsOnExtension {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn generated_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::GENERATED_KW)
     }
     #[inline]
-    pub fn depends_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEPENDS_KW)
+    pub fn identity_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
     }
     #[inline]
-    pub fn extension_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EXTENSION_KW)
+    pub fn including_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INCLUDING_KW)
     }
     #[inline]
-    pub fn no_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NO_KW)
+    pub fn indexes_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INDEXES_KW)
     }
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn statistics_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STATISTICS_KW)
+    }
+    #[inline]
+    pub fn storage_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STORAGE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NoForceRls {
+pub struct LimitClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl NoForceRls {
-    #[inline]
-    pub fn force_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FORCE_KW)
-    }
-    #[inline]
-    pub fn level_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LEVEL_KW)
-    }
+impl LimitClause {
     #[inline]
-    pub fn no_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NO_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn row_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ROW_KW)
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
     }
     #[inline]
-    pub fn security_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SECURITY_KW)
+    pub fn limit_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LIMIT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NoInherit {
+pub struct LimitToTables {
     pub(crate) syntax: SyntaxNode,
 }
-impl NoInherit {
+impl LimitToTables {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
+    pub fn name_refs(&self) -> AstChildren<NameRef> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn inherit_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INHERIT_KW)
+    pub fn limit_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LIMIT_KW)
     }
     #[inline]
-    pub fn no_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NO_KW)
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NoInheritTable {
+pub struct Listen {
     pub(crate) syntax: SyntaxNode,
 }
-impl NoInheritTable {
+impl Listen {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
+    pub fn name(&self) -> Option<Name> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn inherit_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INHERIT_KW)
-    }
-    #[inline]
-    pub fn no_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NO_KW)
+    pub fn listen_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LISTEN_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NonStandardParam {
+pub struct Literal {
     pub(crate) syntax: SyntaxNode,
 }
-impl NonStandardParam {
+impl Literal {}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Load {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Load {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
+    pub fn literal(&self) -> Option<Literal> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn colon_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COLON)
+    pub fn load_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LOAD_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NotDeferrable {
+pub struct Lock {
     pub(crate) syntax: SyntaxNode,
 }
-impl NotDeferrable {
+impl Lock {
     #[inline]
-    pub fn deferrable_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW)
+    pub fn table_list(&self) -> Option<TableList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn lock_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LOCK_KW)
+    }
+    #[inline]
+    pub fn table_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NotDeferrableConstraintOption {
+pub struct LockingClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl NotDeferrableConstraintOption {
-    #[inline]
-    pub fn deferrable_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW)
-    }
+impl LockingClause {
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NotEnforced {
+pub struct Lteq {
     pub(crate) syntax: SyntaxNode,
 }
-impl NotEnforced {
+impl Lteq {
     #[inline]
-    pub fn enforced_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ENFORCED_KW)
+    pub fn l_angle_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_ANGLE)
     }
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn eq_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EQ)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NotIlike {
+pub struct MatchFull {
     pub(crate) syntax: SyntaxNode,
 }
-impl NotIlike {
+impl MatchFull {
     #[inline]
-    pub fn ilike_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ILIKE_KW)
+    pub fn full_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FULL_KW)
     }
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn match_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MATCH_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NotIn {
+pub struct MatchPartial {
     pub(crate) syntax: SyntaxNode,
 }
-impl NotIn {
+impl MatchPartial {
     #[inline]
-    pub fn in_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IN_KW)
+    pub fn match_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MATCH_KW)
     }
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn partial_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PARTIAL_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NotLike {
+pub struct MatchSimple {
     pub(crate) syntax: SyntaxNode,
 }
-impl NotLike {
+impl MatchSimple {
     #[inline]
-    pub fn like_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LIKE_KW)
+    pub fn match_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MATCH_KW)
     }
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn simple_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SIMPLE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NotMaterialized {
+pub struct Materialized {
     pub(crate) syntax: SyntaxNode,
 }
-impl NotMaterialized {
+impl Materialized {
     #[inline]
     pub fn materialized_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
     }
-    #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
-    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NotNullConstraint {
+pub struct Merge {
     pub(crate) syntax: SyntaxNode,
 }
-impl NotNullConstraint {
+impl Merge {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
+    pub fn alias(&self) -> Option<Alias> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn no_inherit(&self) -> Option<NoInherit> {
+    pub fn merge_when_clauses(&self) -> AstChildren<MergeWhenClause> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn relation_name(&self) -> Option<RelationName> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn constraint_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
+    pub fn using_on_clause(&self) -> Option<UsingOnClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn into_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INTO_KW)
     }
     #[inline]
-    pub fn null_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    pub fn merge_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MERGE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NotOf {
+pub struct MergeDelete {
     pub(crate) syntax: SyntaxNode,
 }
-impl NotOf {
-    #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
-    }
+impl MergeDelete {
     #[inline]
-    pub fn of_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OF_KW)
+    pub fn delete_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DELETE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NotSimilarTo {
+pub struct MergeDoNothing {
     pub(crate) syntax: SyntaxNode,
 }
-impl NotSimilarTo {
-    #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
-    }
+impl MergeDoNothing {
     #[inline]
-    pub fn similar_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SIMILAR_KW)
+    pub fn do_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DO_KW)
     }
     #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn nothing_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOTHING_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NotValid {
+pub struct MergeInsert {
     pub(crate) syntax: SyntaxNode,
 }
-impl NotValid {
+impl MergeInsert {
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn column_list(&self) -> Option<ColumnList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn valid_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VALID_KW)
+    pub fn values(&self) -> Option<Values> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Notify {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Notify {
     #[inline]
-    pub fn literal(&self) -> Option<Literal> {
-        support::child(&self.syntax)
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
     }
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn insert_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INSERT_KW)
     }
     #[inline]
-    pub fn comma_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COMMA)
+    pub fn overriding_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OVERRIDING_KW)
     }
     #[inline]
-    pub fn notify_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOTIFY_KW)
+    pub fn system_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SYSTEM_KW)
+    }
+    #[inline]
+    pub fn user_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::USER_KW)
+    }
+    #[inline]
+    pub fn values_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VALUES_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NullConstraint {
+pub struct MergeUpdate {
     pub(crate) syntax: SyntaxNode,
 }
-impl NullConstraint {
+impl MergeUpdate {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
+    pub fn set_clause(&self) -> Option<SetClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn constraint_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
     #[inline]
-    pub fn null_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    pub fn update_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UPDATE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NullsDistinct {
+pub struct MergeWhenMatched {
     pub(crate) syntax: SyntaxNode,
 }
-impl NullsDistinct {
+impl MergeWhenMatched {
     #[inline]
-    pub fn distinct_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn nulls_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULLS_KW)
+    pub fn merge_action(&self) -> Option<MergeAction> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NullsFirst {
-    pub(crate) syntax: SyntaxNode,
-}
-impl NullsFirst {
     #[inline]
-    pub fn first_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FIRST_KW)
+    pub fn and_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AND_KW)
     }
     #[inline]
-    pub fn nulls_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULLS_KW)
+    pub fn matched_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MATCHED_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NullsLast {
-    pub(crate) syntax: SyntaxNode,
-}
-impl NullsLast {
     #[inline]
-    pub fn last_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LAST_KW)
+    pub fn then_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::THEN_KW)
     }
     #[inline]
-    pub fn nulls_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULLS_KW)
+    pub fn when_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WHEN_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NullsNotDistinct {
+pub struct MergeWhenNotMatchedSource {
     pub(crate) syntax: SyntaxNode,
 }
-impl NullsNotDistinct {
+impl MergeWhenNotMatchedSource {
     #[inline]
-    pub fn distinct_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn merge_action(&self) -> Option<MergeAction> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn nulls_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULLS_KW)
+    pub fn and_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AND_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OfType {
-    pub(crate) syntax: SyntaxNode,
-}
-impl OfType {
     #[inline]
-    pub fn ty(&self) -> Option<Type> {
-        support::child(&self.syntax)
+    pub fn by_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::BY_KW)
     }
     #[inline]
-    pub fn of_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OF_KW)
+    pub fn matched_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MATCHED_KW)
+    }
+    #[inline]
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    }
+    #[inline]
+    pub fn source_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SOURCE_KW)
+    }
+    #[inline]
+    pub fn then_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::THEN_KW)
+    }
+    #[inline]
+    pub fn when_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WHEN_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OffsetClause {
+pub struct MergeWhenNotMatchedTarget {
     pub(crate) syntax: SyntaxNode,
 }
-impl OffsetClause {
+impl MergeWhenNotMatchedTarget {
     #[inline]
     pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn offset_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OFFSET_KW)
+    pub fn merge_action(&self) -> Option<MergeAction> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn row_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ROW_KW)
+    pub fn and_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AND_KW)
     }
     #[inline]
-    pub fn rows_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ROWS_KW)
+    pub fn by_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::BY_KW)
+    }
+    #[inline]
+    pub fn matched_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MATCHED_KW)
+    }
+    #[inline]
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    }
+    #[inline]
+    pub fn target_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TARGET_KW)
+    }
+    #[inline]
+    pub fn then_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::THEN_KW)
+    }
+    #[inline]
+    pub fn when_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WHEN_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OnClause {
+pub struct Move {
     pub(crate) syntax: SyntaxNode,
 }
-impl OnClause {
+impl Move {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
+    pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn from_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FROM_KW)
+    }
+    #[inline]
+    pub fn in_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IN_KW)
+    }
+    #[inline]
+    pub fn move_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MOVE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OnCommit {
+pub struct Name {
     pub(crate) syntax: SyntaxNode,
 }
-impl OnCommit {
-    #[inline]
-    pub fn on_commit_action(&self) -> Option<OnCommitAction> {
-        support::child(&self.syntax)
-    }
+impl Name {
     #[inline]
-    pub fn commit_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COMMIT_KW)
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NameRef {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NameRef {
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OnConflictClause {
+pub struct NamedArg {
     pub(crate) syntax: SyntaxNode,
 }
-impl OnConflictClause {
+impl NamedArg {
     #[inline]
-    pub fn conflict_action(&self) -> Option<ConflictAction> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn conflict_target(&self) -> Option<ConflictTarget> {
+    pub fn fat_arrow(&self) -> Option<FatArrow> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn conflict_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONFLICT_KW)
-    }
-    #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OnDeleteAction {
+pub struct Neq {
     pub(crate) syntax: SyntaxNode,
 }
-impl OnDeleteAction {
-    #[inline]
-    pub fn ref_action(&self) -> Option<RefAction> {
-        support::child(&self.syntax)
-    }
+impl Neq {
     #[inline]
-    pub fn delete_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DELETE_KW)
+    pub fn bang_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::BANG)
     }
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn eq_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EQ)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OnTable {
+pub struct Neqb {
     pub(crate) syntax: SyntaxNode,
 }
-impl OnTable {
+impl Neqb {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
+    pub fn l_angle_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_ANGLE)
     }
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn r_angle_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_ANGLE)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OnUpdateAction {
+pub struct NoAction {
     pub(crate) syntax: SyntaxNode,
 }
-impl OnUpdateAction {
-    #[inline]
-    pub fn ref_action(&self) -> Option<RefAction> {
-        support::child(&self.syntax)
-    }
+impl NoAction {
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn action_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ACTION_KW)
     }
     #[inline]
-    pub fn update_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::UPDATE_KW)
+    pub fn no_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NO_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Op {
+pub struct NoDependsOnExtension {
     pub(crate) syntax: SyntaxNode,
 }
-impl Op {
+impl NoDependsOnExtension {
     #[inline]
-    pub fn at_time_zone(&self) -> Option<AtTimeZone> {
+    pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn colon_colon(&self) -> Option<ColonColon> {
-        support::child(&self.syntax)
+    pub fn depends_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEPENDS_KW)
     }
     #[inline]
-    pub fn colon_eq(&self) -> Option<ColonEq> {
-        support::child(&self.syntax)
+    pub fn extension_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EXTENSION_KW)
     }
     #[inline]
-    pub fn custom_op(&self) -> Option<CustomOp> {
-        support::child(&self.syntax)
+    pub fn no_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NO_KW)
     }
     #[inline]
-    pub fn fat_arrow(&self) -> Option<FatArrow> {
-        support::child(&self.syntax)
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NoForceRls {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NoForceRls {
     #[inline]
-    pub fn gteq(&self) -> Option<Gteq> {
-        support::child(&self.syntax)
+    pub fn force_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FORCE_KW)
     }
     #[inline]
-    pub fn is_distinct_from(&self) -> Option<IsDistinctFrom> {
-        support::child(&self.syntax)
+    pub fn level_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LEVEL_KW)
     }
     #[inline]
-    pub fn is_json(&self) -> Option<IsJson> {
-        support::child(&self.syntax)
+    pub fn no_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NO_KW)
     }
     #[inline]
-    pub fn is_json_array(&self) -> Option<IsJsonArray> {
-        support::child(&self.syntax)
+    pub fn row_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROW_KW)
     }
     #[inline]
-    pub fn is_json_object(&self) -> Option<IsJsonObject> {
-        support::child(&self.syntax)
+    pub fn security_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SECURITY_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NoInherit {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NoInherit {
     #[inline]
-    pub fn is_json_scalar(&self) -> Option<IsJsonScalar> {
+    pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn is_json_value(&self) -> Option<IsJsonValue> {
-        support::child(&self.syntax)
+    pub fn inherit_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INHERIT_KW)
     }
     #[inline]
-    pub fn is_not(&self) -> Option<IsNot> {
-        support::child(&self.syntax)
+    pub fn no_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NO_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NoInheritTable {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NoInheritTable {
     #[inline]
-    pub fn is_not_distinct_from(&self) -> Option<IsNotDistinctFrom> {
+    pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn is_not_json(&self) -> Option<IsNotJson> {
-        support::child(&self.syntax)
+    pub fn inherit_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INHERIT_KW)
     }
     #[inline]
-    pub fn is_not_json_array(&self) -> Option<IsNotJsonArray> {
-        support::child(&self.syntax)
+    pub fn no_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NO_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NonStandardParam {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NonStandardParam {
     #[inline]
-    pub fn is_not_json_scalar(&self) -> Option<IsNotJsonScalar> {
+    pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn is_not_json_value(&self) -> Option<IsNotJsonValue> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn lteq(&self) -> Option<Lteq> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn neq(&self) -> Option<Neq> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn neqb(&self) -> Option<Neqb> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn not_ilike(&self) -> Option<NotIlike> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn not_in(&self) -> Option<NotIn> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn not_like(&self) -> Option<NotLike> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn not_similar_to(&self) -> Option<NotSimilarTo> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn operator_call(&self) -> Option<OperatorCall> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn similar_to(&self) -> Option<SimilarTo> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn percent_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PERCENT)
-    }
-    #[inline]
-    pub fn plus_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PLUS)
-    }
-    #[inline]
-    pub fn minus_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MINUS)
-    }
-    #[inline]
-    pub fn slash_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SLASH)
-    }
-    #[inline]
     pub fn colon_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::COLON)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NotDeferrable {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NotDeferrable {
     #[inline]
-    pub fn l_angle_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_ANGLE)
+    pub fn deferrable_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW)
     }
     #[inline]
-    pub fn eq_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EQ)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NotDeferrableConstraintOption {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NotDeferrableConstraintOption {
     #[inline]
-    pub fn r_angle_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_ANGLE)
+    pub fn deferrable_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW)
     }
     #[inline]
-    pub fn caret_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CARET)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NotEnforced {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NotEnforced {
     #[inline]
-    pub fn and_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AND_KW)
+    pub fn enforced_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ENFORCED_KW)
     }
     #[inline]
-    pub fn collate_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COLLATE_KW)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NotIlike {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NotIlike {
     #[inline]
     pub fn ilike_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::ILIKE_KW)
     }
+    #[inline]
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NotIn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NotIn {
     #[inline]
     pub fn in_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::IN_KW)
     }
     #[inline]
-    pub fn is_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IS_KW)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NotLike {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NotLike {
     #[inline]
     pub fn like_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::LIKE_KW)
     }
     #[inline]
-    pub fn or_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OR_KW)
-    }
-    #[inline]
-    pub fn overlaps_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OVERLAPS_KW)
-    }
-    #[inline]
-    pub fn value_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VALUE_KW)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OpClassOption {
+pub struct NotMaterialized {
     pub(crate) syntax: SyntaxNode,
 }
-impl OpClassOption {
-    #[inline]
-    pub fn function_sig(&self) -> Option<FunctionSig> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn literal(&self) -> Option<Literal> {
-        support::child(&self.syntax)
-    }
+impl NotMaterialized {
     #[inline]
-    pub fn op(&self) -> Option<Op> {
-        support::child(&self.syntax)
+    pub fn materialized_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
     }
     #[inline]
-    pub fn param_list(&self) -> Option<ParamList> {
-        support::child(&self.syntax)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NotNullConstraint {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NotNullConstraint {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
+    pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn ty(&self) -> Option<Type> {
+    pub fn no_inherit(&self) -> Option<NoInherit> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn constraint_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
     #[inline]
-    pub fn comma_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COMMA)
+    pub fn null_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULL_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NotOf {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NotOf {
     #[inline]
-    pub fn by_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::BY_KW)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
     #[inline]
-    pub fn for_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    pub fn of_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OF_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NotSimilarTo {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NotSimilarTo {
     #[inline]
-    pub fn function_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
     #[inline]
-    pub fn operator_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
+    pub fn similar_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SIMILAR_KW)
     }
     #[inline]
-    pub fn order_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ORDER_KW)
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NotValid {
+    pub(crate) syntax: SyntaxNode,
+}
+impl NotValid {
     #[inline]
-    pub fn search_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SEARCH_KW)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
     #[inline]
-    pub fn storage_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::STORAGE_KW)
+    pub fn valid_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VALID_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OpSig {
+pub struct Notify {
     pub(crate) syntax: SyntaxNode,
 }
-impl OpSig {
+impl Notify {
     #[inline]
-    pub fn op(&self) -> Option<Op> {
+    pub fn literal(&self) -> Option<Literal> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
-    }
-    #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
     }
     #[inline]
     pub fn comma_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::COMMA)
     }
     #[inline]
-    pub fn none_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NONE_KW)
+    pub fn notify_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOTIFY_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OpSigList {
+pub struct NullConstraint {
     pub(crate) syntax: SyntaxNode,
 }
-impl OpSigList {
+impl NullConstraint {
     #[inline]
-    pub fn op_sigs(&self) -> AstChildren<OpSig> {
-        support::children(&self.syntax)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OperatorCall {
-    pub(crate) syntax: SyntaxNode,
-}
-impl OperatorCall {
-    #[inline]
-    pub fn op(&self) -> Option<Op> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn path(&self) -> Option<Path> {
+    pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
-    }
-    #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
-    }
-    #[inline]
-    pub fn dot_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DOT)
+    pub fn constraint_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
     }
     #[inline]
-    pub fn operator_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
+    pub fn null_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULL_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OperatorClassOptionList {
+pub struct NullsDistinct {
     pub(crate) syntax: SyntaxNode,
 }
-impl OperatorClassOptionList {
+impl NullsDistinct {
     #[inline]
-    pub fn op_class_options(&self) -> AstChildren<OpClassOption> {
-        support::children(&self.syntax)
+    pub fn distinct_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
+    }
+    #[inline]
+    pub fn nulls_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULLS_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OptionItem {
+pub struct NullsFirst {
     pub(crate) syntax: SyntaxNode,
 }
-impl OptionItem {
+impl NullsFirst {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
+    pub fn first_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FIRST_KW)
     }
     #[inline]
-    pub fn default_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    pub fn nulls_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULLS_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OptionItemList {
+pub struct NullsLast {
     pub(crate) syntax: SyntaxNode,
 }
-impl OptionItemList {
-    #[inline]
-    pub fn option_items(&self) -> AstChildren<OptionItem> {
-        support::children(&self.syntax)
-    }
+impl NullsLast {
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn last_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LAST_KW)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn nulls_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULLS_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OrReplace {
+pub struct NullsNotDistinct {
     pub(crate) syntax: SyntaxNode,
 }
-impl OrReplace {
+impl NullsNotDistinct {
     #[inline]
-    pub fn or_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OR_KW)
+    pub fn distinct_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
     }
     #[inline]
-    pub fn replace_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REPLACE_KW)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    }
+    #[inline]
+    pub fn nulls_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULLS_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OrderByClause {
+pub struct OfType {
     pub(crate) syntax: SyntaxNode,
 }
-impl OrderByClause {
+impl OfType {
     #[inline]
-    pub fn sort_by_list(&self) -> Option<SortByList> {
+    pub fn ty(&self) -> Option<Type> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn by_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::BY_KW)
-    }
-    #[inline]
-    pub fn order_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ORDER_KW)
+    pub fn of_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OF_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OverClause {
+pub struct OffsetClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl OverClause {
+impl OffsetClause {
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn offset_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OFFSET_KW)
     }
     #[inline]
-    pub fn over_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OVER_KW)
+    pub fn row_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROW_KW)
+    }
+    #[inline]
+    pub fn rows_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROWS_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct OwnerTo {
+pub struct OnClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl OwnerTo {
+impl OnClause {
     #[inline]
-    pub fn role(&self) -> Option<Role> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn owner_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OWNER_KW)
-    }
-    #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParallelFuncOption {
+pub struct OnCommit {
     pub(crate) syntax: SyntaxNode,
 }
-impl ParallelFuncOption {
+impl OnCommit {
     #[inline]
-    pub fn ident_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENT)
+    pub fn on_commit_action(&self) -> Option<OnCommitAction> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn parallel_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PARALLEL_KW)
+    pub fn commit_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMIT_KW)
+    }
+    #[inline]
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Param {
+pub struct OnConflictClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl Param {
+impl OnConflictClause {
     #[inline]
-    pub fn mode(&self) -> Option<ParamMode> {
+    pub fn conflict_action(&self) -> Option<ConflictAction> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn conflict_target(&self) -> Option<ConflictTarget> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn param_default(&self) -> Option<ParamDefault> {
-        support::child(&self.syntax)
+    pub fn conflict_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONFLICT_KW)
     }
     #[inline]
-    pub fn ty(&self) -> Option<Type> {
-        support::child(&self.syntax)
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParamDefault {
+pub struct OnDeleteAction {
     pub(crate) syntax: SyntaxNode,
 }
-impl ParamDefault {
+impl OnDeleteAction {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
+    pub fn ref_action(&self) -> Option<RefAction> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn eq_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EQ)
+    pub fn delete_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DELETE_KW)
     }
     #[inline]
-    pub fn default_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParamIn {
+pub struct OnTable {
     pub(crate) syntax: SyntaxNode,
 }
-impl ParamIn {
+impl OnTable {
     #[inline]
-    pub fn in_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IN_KW)
+    pub fn path(&self) -> Option<Path> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParamInOut {
+pub struct OnUpdateAction {
     pub(crate) syntax: SyntaxNode,
 }
-impl ParamInOut {
+impl OnUpdateAction {
     #[inline]
-    pub fn in_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IN_KW)
+    pub fn ref_action(&self) -> Option<RefAction> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn inout_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INOUT_KW)
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
     #[inline]
-    pub fn out_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OUT_KW)
+    pub fn update_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UPDATE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParamList {
+pub struct Op {
     pub(crate) syntax: SyntaxNode,
 }
-impl ParamList {
+impl Op {
     #[inline]
-    pub fn params(&self) -> AstChildren<Param> {
-        support::children(&self.syntax)
+    pub fn at_time_zone(&self) -> Option<AtTimeZone> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParamOut {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ParamOut {
     #[inline]
-    pub fn out_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OUT_KW)
+    pub fn colon_colon(&self) -> Option<ColonColon> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParamVariadic {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ParamVariadic {
     #[inline]
-    pub fn variadic_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VARIADIC_KW)
+    pub fn colon_eq(&self) -> Option<ColonEq> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParenExpr {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ParenExpr {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
+    pub fn custom_op(&self) -> Option<CustomOp> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn select(&self) -> Option<Select> {
+    pub fn fat_arrow(&self) -> Option<FatArrow> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn gteq(&self) -> Option<Gteq> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParenSelect {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ParenSelect {
+    pub fn is_distinct_from(&self) -> Option<IsDistinctFrom> {
+        support::child(&self.syntax)
+    }
     #[inline]
-    pub fn select(&self) -> Option<SelectVariant> {
+    pub fn is_json(&self) -> Option<IsJson> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn is_json_array(&self) -> Option<IsJsonArray> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn is_json_object(&self) -> Option<IsJsonObject> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PartitionBy {
-    pub(crate) syntax: SyntaxNode,
-}
-impl PartitionBy {
     #[inline]
-    pub fn partition_item_list(&self) -> Option<PartitionItemList> {
+    pub fn is_json_scalar(&self) -> Option<IsJsonScalar> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn by_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::BY_KW)
+    pub fn is_json_value(&self) -> Option<IsJsonValue> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn ident_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENT)
+    pub fn is_not(&self) -> Option<IsNot> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn partition_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PARTITION_KW)
+    pub fn is_not_distinct_from(&self) -> Option<IsNotDistinctFrom> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn range_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RANGE_KW)
+    pub fn is_not_json(&self) -> Option<IsNotJson> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PartitionDefault {
-    pub(crate) syntax: SyntaxNode,
-}
-impl PartitionDefault {
     #[inline]
-    pub fn default_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    pub fn is_not_json_array(&self) -> Option<IsNotJsonArray> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PartitionForValuesFrom {
-    pub(crate) syntax: SyntaxNode,
-}
-impl PartitionForValuesFrom {
     #[inline]
-    pub fn exprs(&self) -> AstChildren<Expr> {
-        support::children(&self.syntax)
+    pub fn is_not_json_scalar(&self) -> Option<IsNotJsonScalar> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn is_not_json_value(&self) -> Option<IsNotJsonValue> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn lteq(&self) -> Option<Lteq> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn for_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    pub fn neq(&self) -> Option<Neq> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn from_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FROM_KW)
+    pub fn neqb(&self) -> Option<Neqb> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn not_ilike(&self) -> Option<NotIlike> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn values_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VALUES_KW)
+    pub fn not_in(&self) -> Option<NotIn> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PartitionForValuesIn {
-    pub(crate) syntax: SyntaxNode,
-}
-impl PartitionForValuesIn {
     #[inline]
-    pub fn exprs(&self) -> AstChildren<Expr> {
-        support::children(&self.syntax)
+    pub fn not_like(&self) -> Option<NotLike> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn not_similar_to(&self) -> Option<NotSimilarTo> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn operator_call(&self) -> Option<OperatorCall> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn for_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    pub fn similar_to(&self) -> Option<SimilarTo> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn percent_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PERCENT)
+    }
+    #[inline]
+    pub fn plus_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PLUS)
+    }
+    #[inline]
+    pub fn minus_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MINUS)
+    }
+    #[inline]
+    pub fn slash_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SLASH)
+    }
+    #[inline]
+    pub fn colon_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COLON)
+    }
+    #[inline]
+    pub fn l_angle_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_ANGLE)
+    }
+    #[inline]
+    pub fn eq_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EQ)
+    }
+    #[inline]
+    pub fn r_angle_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_ANGLE)
+    }
+    #[inline]
+    pub fn caret_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CARET)
+    }
+    #[inline]
+    pub fn and_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AND_KW)
+    }
+    #[inline]
+    pub fn collate_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COLLATE_KW)
+    }
+    #[inline]
+    pub fn ilike_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ILIKE_KW)
     }
     #[inline]
     pub fn in_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::IN_KW)
     }
     #[inline]
-    pub fn values_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VALUES_KW)
+    pub fn is_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IS_KW)
+    }
+    #[inline]
+    pub fn like_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LIKE_KW)
+    }
+    #[inline]
+    pub fn or_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OR_KW)
+    }
+    #[inline]
+    pub fn overlaps_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OVERLAPS_KW)
+    }
+    #[inline]
+    pub fn value_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VALUE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PartitionForValuesWith {
+pub struct OpClassOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl PartitionForValuesWith {
+impl OpClassOption {
+    #[inline]
+    pub fn function_sig(&self) -> Option<FunctionSig> {
+        support::child(&self.syntax)
+    }
     #[inline]
     pub fn literal(&self) -> Option<Literal> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn op(&self) -> Option<Op> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn param_list(&self) -> Option<ParamList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn path(&self) -> Option<Path> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn ty(&self) -> Option<Type> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn l_paren_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
@@ -10547,46 +11124,43 @@ impl PartitionForValuesWith {
         support::token(&self.syntax, SyntaxKind::COMMA)
     }
     #[inline]
+    pub fn by_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::BY_KW)
+    }
+    #[inline]
     pub fn for_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::FOR_KW)
     }
     #[inline]
-    pub fn ident_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENT)
+    pub fn function_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
     }
     #[inline]
-    pub fn values_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VALUES_KW)
+    pub fn operator_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
     }
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn order_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ORDER_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PartitionItem {
-    pub(crate) syntax: SyntaxNode,
-}
-impl PartitionItem {
     #[inline]
-    pub fn collate(&self) -> Option<Collate> {
-        support::child(&self.syntax)
+    pub fn search_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SEARCH_KW)
     }
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
+    pub fn storage_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STORAGE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PartitionItemList {
+pub struct OpSig {
     pub(crate) syntax: SyntaxNode,
 }
-impl PartitionItemList {
+impl OpSig {
     #[inline]
-    pub fn partition_items(&self) -> AstChildren<PartitionItem> {
-        support::children(&self.syntax)
+    pub fn op(&self) -> Option<Op> {
+        support::child(&self.syntax)
     }
     #[inline]
     pub fn l_paren_token(&self) -> Option<SyntaxToken> {
@@ -10596,192 +11170,236 @@ impl PartitionItemList {
     pub fn r_paren_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
+    #[inline]
+    pub fn comma_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMA)
+    }
+    #[inline]
+    pub fn none_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NONE_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PartitionOf {
+pub struct OpSigList {
     pub(crate) syntax: SyntaxNode,
 }
-impl PartitionOf {
-    #[inline]
-    pub fn ty(&self) -> Option<Type> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn of_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OF_KW)
-    }
+impl OpSigList {
     #[inline]
-    pub fn partition_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PARTITION_KW)
+    pub fn op_sigs(&self) -> AstChildren<OpSig> {
+        support::children(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Path {
+pub struct OperatorCall {
     pub(crate) syntax: SyntaxNode,
 }
-impl Path {
+impl OperatorCall {
     #[inline]
-    pub fn qualifier(&self) -> Option<Path> {
+    pub fn op(&self) -> Option<Op> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn segment(&self) -> Option<PathSegment> {
+    pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
     pub fn dot_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::DOT)
     }
+    #[inline]
+    pub fn operator_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PathSegment {
+pub struct OperatorClassOptionList {
     pub(crate) syntax: SyntaxNode,
 }
-impl PathSegment {
-    #[inline]
-    pub fn name(&self) -> Option<Name> {
-        support::child(&self.syntax)
-    }
+impl OperatorClassOptionList {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn op_class_options(&self) -> AstChildren<OpClassOption> {
+        support::children(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PathType {
+pub struct OptionItem {
     pub(crate) syntax: SyntaxNode,
 }
-impl PathType {
+impl OptionItem {
     #[inline]
-    pub fn arg_list(&self) -> Option<ArgList> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PercentType {
+pub struct OptionItemList {
     pub(crate) syntax: SyntaxNode,
 }
-impl PercentType {
+impl OptionItemList {
     #[inline]
-    pub fn percent_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PERCENT)
+    pub fn option_items(&self) -> AstChildren<OptionItem> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn type_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TYPE_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PercentTypeClause {
+pub struct OrReplace {
     pub(crate) syntax: SyntaxNode,
 }
-impl PercentTypeClause {
+impl OrReplace {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
+    pub fn or_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OR_KW)
     }
     #[inline]
-    pub fn percent_type_clause(&self) -> Option<PercentTypeClause> {
-        support::child(&self.syntax)
+    pub fn replace_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REPLACE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PostfixExpr {
+pub struct OrderByClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl PostfixExpr {
+impl OrderByClause {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
+    pub fn sort_by_list(&self) -> Option<SortByList> {
         support::child(&self.syntax)
     }
+    #[inline]
+    pub fn by_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::BY_KW)
+    }
+    #[inline]
+    pub fn order_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ORDER_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PrefixExpr {
+pub struct OverClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl PrefixExpr {
+impl OverClause {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn over_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OVER_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Prepare {
+pub struct OverlayFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl Prepare {
+impl OverlayFn {
     #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn preparable_stmt(&self) -> Option<PreparableStmt> {
-        support::child(&self.syntax)
+    pub fn exprs(&self) -> AstChildren<Expr> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn as_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AS_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn prepare_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PREPARE_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    }
+    #[inline]
+    pub fn from_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FROM_KW)
+    }
+    #[inline]
+    pub fn overlay_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OVERLAY_KW)
+    }
+    #[inline]
+    pub fn placing_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PLACING_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PrepareTransaction {
+pub struct OwnerTo {
     pub(crate) syntax: SyntaxNode,
 }
-impl PrepareTransaction {
+impl OwnerTo {
     #[inline]
-    pub fn literal(&self) -> Option<Literal> {
+    pub fn role(&self) -> Option<Role> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn prepare_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PREPARE_KW)
+    pub fn owner_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OWNER_KW)
     }
     #[inline]
-    pub fn transaction_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PreserveRows {
+pub struct ParallelFuncOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl PreserveRows {
+impl ParallelFuncOption {
     #[inline]
-    pub fn preserve_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PRESERVE_KW)
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
     }
     #[inline]
-    pub fn rows_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ROWS_KW)
+    pub fn parallel_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PARALLEL_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PrimaryKeyConstraint {
+pub struct Param {
     pub(crate) syntax: SyntaxNode,
 }
-impl PrimaryKeyConstraint {
+impl Param {
     #[inline]
-    pub fn column_list(&self) -> Option<ColumnList> {
+    pub fn mode(&self) -> Option<ParamMode> {
         support::child(&self.syntax)
     }
     #[inline]
@@ -10789,176 +11407,146 @@ impl PrimaryKeyConstraint {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn partition_item_list(&self) -> Option<PartitionItemList> {
+    pub fn param_default(&self) -> Option<ParamDefault> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn using_index(&self) -> Option<UsingIndex> {
+    pub fn ty(&self) -> Option<Type> {
         support::child(&self.syntax)
     }
-    #[inline]
-    pub fn constraint_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
-    }
-    #[inline]
-    pub fn key_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::KEY_KW)
-    }
-    #[inline]
-    pub fn primary_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PRIMARY_KW)
-    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PrivilegeTarget {
+pub struct ParamDefault {
     pub(crate) syntax: SyntaxNode,
 }
-impl PrivilegeTarget {
-    #[inline]
-    pub fn functions_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FUNCTIONS_KW)
-    }
-    #[inline]
-    pub fn large_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LARGE_KW)
-    }
-    #[inline]
-    pub fn objects_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OBJECTS_KW)
-    }
-    #[inline]
-    pub fn routines_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ROUTINES_KW)
-    }
-    #[inline]
-    pub fn schemas_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SCHEMAS_KW)
-    }
+impl ParamDefault {
     #[inline]
-    pub fn sequences_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SEQUENCES_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn tables_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLES_KW)
+    pub fn eq_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EQ)
     }
     #[inline]
-    pub fn types_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TYPES_KW)
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Privileges {
+pub struct ParamIn {
     pub(crate) syntax: SyntaxNode,
 }
-impl Privileges {
+impl ParamIn {
     #[inline]
-    pub fn column_list(&self) -> Option<ColumnList> {
-        support::child(&self.syntax)
+    pub fn in_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IN_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParamInOut {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ParamInOut {
     #[inline]
-    pub fn revoke_command_list(&self) -> Option<RevokeCommandList> {
-        support::child(&self.syntax)
+    pub fn in_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IN_KW)
     }
     #[inline]
-    pub fn all_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    pub fn inout_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INOUT_KW)
     }
     #[inline]
-    pub fn privileges_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PRIVILEGES_KW)
+    pub fn out_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OUT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReadCommitted {
+pub struct ParamList {
     pub(crate) syntax: SyntaxNode,
 }
-impl ReadCommitted {
+impl ParamList {
     #[inline]
-    pub fn committed_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COMMITTED_KW)
-    }
-    #[inline]
-    pub fn isolation_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
-    }
-    #[inline]
-    pub fn level_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LEVEL_KW)
-    }
-    #[inline]
-    pub fn read_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::READ_KW)
+    pub fn params(&self) -> AstChildren<Param> {
+        support::children(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReadOnly {
+pub struct ParamOut {
     pub(crate) syntax: SyntaxNode,
 }
-impl ReadOnly {
+impl ParamOut {
     #[inline]
-    pub fn only_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ONLY_KW)
+    pub fn out_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OUT_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParamVariadic {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ParamVariadic {
     #[inline]
-    pub fn read_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::READ_KW)
+    pub fn variadic_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VARIADIC_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReadUncommitted {
+pub struct ParenExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl ReadUncommitted {
+impl ParenExpr {
     #[inline]
-    pub fn isolation_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn level_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LEVEL_KW)
+    pub fn select(&self) -> Option<Select> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn read_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::READ_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn uncommitted_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::UNCOMMITTED_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReadWrite {
+pub struct ParenSelect {
     pub(crate) syntax: SyntaxNode,
 }
-impl ReadWrite {
+impl ParenSelect {
     #[inline]
-    pub fn read_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::READ_KW)
+    pub fn select(&self) -> Option<SelectVariant> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn write_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WRITE_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Reassign {
+pub struct PartitionBy {
     pub(crate) syntax: SyntaxNode,
 }
-impl Reassign {
-    #[inline]
-    pub fn new_roles(&self) -> Option<RoleList> {
-        support::child(&self.syntax)
-    }
+impl PartitionBy {
     #[inline]
-    pub fn old_roles(&self) -> Option<RoleList> {
+    pub fn partition_item_list(&self) -> Option<PartitionItemList> {
         support::child(&self.syntax)
     }
     #[inline]
@@ -10966,47 +11554,38 @@ impl Reassign {
         support::token(&self.syntax, SyntaxKind::BY_KW)
     }
     #[inline]
-    pub fn owned_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OWNED_KW)
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
     }
     #[inline]
-    pub fn reassign_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REASSIGN_KW)
+    pub fn partition_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PARTITION_KW)
     }
     #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn range_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RANGE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReferencesConstraint {
+pub struct PartitionDefault {
     pub(crate) syntax: SyntaxNode,
 }
-impl ReferencesConstraint {
-    #[inline]
-    pub fn match_type(&self) -> Option<MatchType> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn name(&self) -> Option<Name> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn on_delete_action(&self) -> Option<OnDeleteAction> {
-        support::child(&self.syntax)
-    }
+impl PartitionDefault {
     #[inline]
-    pub fn on_update_action(&self) -> Option<OnUpdateAction> {
-        support::child(&self.syntax)
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PartitionForValuesFrom {
+    pub(crate) syntax: SyntaxNode,
+}
+impl PartitionForValuesFrom {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
+    pub fn exprs(&self) -> AstChildren<Expr> {
+        support::children(&self.syntax)
     }
     #[inline]
     pub fn l_paren_token(&self) -> Option<SyntaxToken> {
@@ -11017,507 +11596,448 @@ impl ReferencesConstraint {
         support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn constraint_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
     }
     #[inline]
-    pub fn references_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REFERENCES_KW)
+    pub fn from_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FROM_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Referencing {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Referencing {
     #[inline]
-    pub fn referencing_tables(&self) -> AstChildren<ReferencingTable> {
-        support::children(&self.syntax)
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
     }
     #[inline]
-    pub fn referencing_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REFERENCING_KW)
+    pub fn values_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VALUES_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReferencingTable {
+pub struct PartitionForValuesIn {
     pub(crate) syntax: SyntaxNode,
 }
-impl ReferencingTable {
+impl PartitionForValuesIn {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn exprs(&self) -> AstChildren<Expr> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn as_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AS_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn new_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NEW_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn old_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OLD_KW)
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
     }
     #[inline]
-    pub fn table_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLE_KW)
+    pub fn in_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IN_KW)
+    }
+    #[inline]
+    pub fn values_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VALUES_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Refresh {
+pub struct PartitionForValuesWith {
     pub(crate) syntax: SyntaxNode,
 }
-impl Refresh {
+impl PartitionForValuesWith {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
+    pub fn literal(&self) -> Option<Literal> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn with_data(&self) -> Option<WithData> {
-        support::child(&self.syntax)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn with_no_data(&self) -> Option<WithNoData> {
-        support::child(&self.syntax)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn concurrently_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW)
+    pub fn comma_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMA)
     }
     #[inline]
-    pub fn materialized_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
     }
     #[inline]
-    pub fn refresh_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REFRESH_KW)
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
     }
     #[inline]
-    pub fn view_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VIEW_KW)
+    pub fn values_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VALUES_KW)
+    }
+    #[inline]
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RefreshCollationVersion {
+pub struct PartitionItem {
     pub(crate) syntax: SyntaxNode,
 }
-impl RefreshCollationVersion {
-    #[inline]
-    pub fn collation_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COLLATION_KW)
-    }
+impl PartitionItem {
     #[inline]
-    pub fn refresh_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REFRESH_KW)
+    pub fn collate(&self) -> Option<Collate> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn version_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VERSION_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RefreshVersion {
+pub struct PartitionItemList {
     pub(crate) syntax: SyntaxNode,
 }
-impl RefreshVersion {
+impl PartitionItemList {
     #[inline]
-    pub fn refresh_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REFRESH_KW)
+    pub fn partition_items(&self) -> AstChildren<PartitionItem> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn version_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VERSION_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Reindex {
+pub struct PartitionOf {
     pub(crate) syntax: SyntaxNode,
 }
-impl Reindex {
+impl PartitionOf {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
+    pub fn ty(&self) -> Option<Type> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn database_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DATABASE_KW)
+    pub fn of_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OF_KW)
     }
     #[inline]
-    pub fn index_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INDEX_KW)
-    }
-    #[inline]
-    pub fn reindex_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REINDEX_KW)
-    }
-    #[inline]
-    pub fn schema_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
-    }
-    #[inline]
-    pub fn system_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SYSTEM_KW)
-    }
-    #[inline]
-    pub fn table_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLE_KW)
+    pub fn partition_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PARTITION_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RelationName {
+pub struct Path {
     pub(crate) syntax: SyntaxNode,
 }
-impl RelationName {
+impl Path {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
+    pub fn qualifier(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
-    }
-    #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
-    }
-    #[inline]
-    pub fn star_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::STAR)
+    pub fn segment(&self) -> Option<PathSegment> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn only_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ONLY_KW)
+    pub fn dot_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DOT)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReleaseSavepoint {
+pub struct PathSegment {
     pub(crate) syntax: SyntaxNode,
 }
-impl ReleaseSavepoint {
+impl PathSegment {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
+    pub fn name(&self) -> Option<Name> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn release_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RELEASE_KW)
-    }
-    #[inline]
-    pub fn savepoint_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RenameColumn {
+pub struct PathType {
     pub(crate) syntax: SyntaxNode,
 }
-impl RenameColumn {
-    #[inline]
-    pub fn column_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COLUMN_KW)
-    }
+impl PathType {
     #[inline]
-    pub fn rename_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RENAME_KW)
+    pub fn arg_list(&self) -> Option<ArgList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn path(&self) -> Option<Path> {
+        support::child(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RenameConstraint {
+pub struct PercentType {
     pub(crate) syntax: SyntaxNode,
 }
-impl RenameConstraint {
-    #[inline]
-    pub fn name(&self) -> Option<Name> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn constraint_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
-    }
+impl PercentType {
     #[inline]
-    pub fn rename_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RENAME_KW)
+    pub fn percent_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PERCENT)
     }
     #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn type_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TYPE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RenameTo {
+pub struct PercentTypeClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl RenameTo {
+impl PercentTypeClause {
     #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn rename_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RENAME_KW)
-    }
-    #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn percent_type_clause(&self) -> Option<PercentTypeClause> {
+        support::child(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RepeatableRead {
+pub struct PositionFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl RepeatableRead {
+impl PositionFn {
     #[inline]
-    pub fn isolation_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn level_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LEVEL_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn read_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::READ_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn repeatable_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REPEATABLE_KW)
+    pub fn in_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IN_KW)
+    }
+    #[inline]
+    pub fn position_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::POSITION_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReplicaIdentity {
+pub struct PostfixExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl ReplicaIdentity {
+impl PostfixExpr {
     #[inline]
-    pub fn identity_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PrefixExpr {
+    pub(crate) syntax: SyntaxNode,
+}
+impl PrefixExpr {
     #[inline]
-    pub fn replica_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REPLICA_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Reset {
+pub struct Prepare {
     pub(crate) syntax: SyntaxNode,
 }
-impl Reset {
+impl Prepare {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
+    pub fn name(&self) -> Option<Name> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn all_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    pub fn preparable_stmt(&self) -> Option<PreparableStmt> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn reset_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESET_KW)
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
+    }
+    #[inline]
+    pub fn prepare_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PREPARE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ResetConfigParam {
+pub struct PrepareTransaction {
     pub(crate) syntax: SyntaxNode,
 }
-impl ResetConfigParam {
+impl PrepareTransaction {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
+    pub fn literal(&self) -> Option<Literal> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn all_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    pub fn prepare_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PREPARE_KW)
     }
     #[inline]
-    pub fn reset_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESET_KW)
+    pub fn transaction_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ResetFuncOption {
+pub struct PreserveRows {
     pub(crate) syntax: SyntaxNode,
 }
-impl ResetFuncOption {
+impl PreserveRows {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn preserve_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PRESERVE_KW)
     }
     #[inline]
-    pub fn reset_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESET_KW)
+    pub fn rows_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROWS_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ResetOptions {
+pub struct PrimaryKeyConstraint {
     pub(crate) syntax: SyntaxNode,
 }
-impl ResetOptions {
+impl PrimaryKeyConstraint {
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn column_list(&self) -> Option<ColumnList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn reset_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESET_KW)
+    pub fn partition_item_list(&self) -> Option<PartitionItemList> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ResetSessionAuth {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ResetSessionAuth {
     #[inline]
-    pub fn authorization_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW)
+    pub fn using_index(&self) -> Option<UsingIndex> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn reset_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESET_KW)
+    pub fn constraint_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
     }
     #[inline]
-    pub fn session_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SESSION_KW)
+    pub fn key_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::KEY_KW)
+    }
+    #[inline]
+    pub fn primary_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PRIMARY_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Restart {
+pub struct PrivilegeTarget {
     pub(crate) syntax: SyntaxNode,
 }
-impl Restart {
+impl PrivilegeTarget {
     #[inline]
-    pub fn restart_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESTART_KW)
+    pub fn functions_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FUNCTIONS_KW)
     }
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn large_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LARGE_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Restrict {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Restrict {
     #[inline]
-    pub fn restrict_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
+    pub fn objects_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OBJECTS_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RetType {
-    pub(crate) syntax: SyntaxNode,
-}
-impl RetType {
     #[inline]
-    pub fn ty(&self) -> Option<Type> {
-        support::child(&self.syntax)
+    pub fn routines_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROUTINES_KW)
     }
     #[inline]
-    pub fn returns_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RETURNS_KW)
+    pub fn schemas_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SCHEMAS_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReturnFuncOption {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ReturnFuncOption {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
+    pub fn sequences_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SEQUENCES_KW)
     }
     #[inline]
-    pub fn return_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RETURN_KW)
+    pub fn tables_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLES_KW)
+    }
+    #[inline]
+    pub fn types_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TYPES_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReturningClause {
+pub struct Privileges {
     pub(crate) syntax: SyntaxNode,
 }
-impl ReturningClause {
+impl Privileges {
     #[inline]
-    pub fn returning_option_list(&self) -> Option<ReturningOptionList> {
+    pub fn column_list(&self) -> Option<ColumnList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn target_list(&self) -> Option<TargetList> {
+    pub fn revoke_command_list(&self) -> Option<RevokeCommandList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn returning_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RETURNING_KW)
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    }
+    #[inline]
+    pub fn privileges_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PRIVILEGES_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReturningOption {
+pub struct PublicationObject {
     pub(crate) syntax: SyntaxNode,
 }
-impl ReturningOption {
+impl PublicationObject {
     #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn column_list(&self) -> Option<ColumnList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn as_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AS_KW)
-    }
-    #[inline]
-    pub fn new_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NEW_KW)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn old_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OLD_KW)
+    pub fn path(&self) -> Option<Path> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReturningOptionList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ReturningOptionList {
     #[inline]
-    pub fn returning_options(&self) -> AstChildren<ReturningOption> {
-        support::children(&self.syntax)
+    pub fn where_condition_clause(&self) -> Option<WhereConditionClause> {
+        support::child(&self.syntax)
     }
     #[inline]
     pub fn l_paren_token(&self) -> Option<SyntaxToken> {
@@ -11528,1394 +12048,1443 @@ impl ReturningOptionList {
         support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Revoke {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Revoke {
-    #[inline]
-    pub fn name_refs(&self) -> AstChildren<NameRef> {
-        support::children(&self.syntax)
-    }
-    #[inline]
-    pub fn paths(&self) -> AstChildren<Path> {
-        support::children(&self.syntax)
-    }
-    #[inline]
-    pub fn revoke_command_list(&self) -> Option<RevokeCommandList> {
-        support::child(&self.syntax)
+    pub fn star_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STAR)
     }
     #[inline]
-    pub fn role(&self) -> Option<Role> {
-        support::child(&self.syntax)
+    pub fn current_schema_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CURRENT_SCHEMA_KW)
     }
     #[inline]
-    pub fn role_list(&self) -> Option<RoleList> {
-        support::child(&self.syntax)
+    pub fn in_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IN_KW)
     }
     #[inline]
-    pub fn all_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    pub fn only_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ONLY_KW)
     }
     #[inline]
-    pub fn by_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::BY_KW)
+    pub fn schema_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
     }
     #[inline]
-    pub fn cascade_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CASCADE_KW)
+    pub fn table_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLE_KW)
     }
     #[inline]
-    pub fn for_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    pub fn tables_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLES_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ReadCommitted {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ReadCommitted {
     #[inline]
-    pub fn from_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FROM_KW)
+    pub fn committed_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMITTED_KW)
     }
     #[inline]
-    pub fn grant_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::GRANT_KW)
+    pub fn isolation_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
     }
     #[inline]
-    pub fn granted_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::GRANTED_KW)
+    pub fn level_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LEVEL_KW)
     }
     #[inline]
-    pub fn in_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IN_KW)
+    pub fn read_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::READ_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ReadOnly {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ReadOnly {
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn only_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ONLY_KW)
     }
     #[inline]
-    pub fn option_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OPTION_KW)
+    pub fn read_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::READ_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ReadUncommitted {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ReadUncommitted {
     #[inline]
-    pub fn privileges_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PRIVILEGES_KW)
+    pub fn isolation_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
     }
     #[inline]
-    pub fn restrict_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
+    pub fn level_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LEVEL_KW)
     }
     #[inline]
-    pub fn revoke_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REVOKE_KW)
+    pub fn read_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::READ_KW)
     }
     #[inline]
-    pub fn schema_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
+    pub fn uncommitted_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UNCOMMITTED_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ReadWrite {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ReadWrite {
     #[inline]
-    pub fn table_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLE_KW)
+    pub fn read_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::READ_KW)
     }
     #[inline]
-    pub fn tables_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLES_KW)
+    pub fn write_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WRITE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RevokeCommand {
+pub struct Reassign {
     pub(crate) syntax: SyntaxNode,
 }
-impl RevokeCommand {
+impl Reassign {
     #[inline]
-    pub fn role(&self) -> Option<Role> {
+    pub fn new_roles(&self) -> Option<RoleList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn all_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    pub fn old_roles(&self) -> Option<RoleList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn alter_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ALTER_KW)
+    pub fn by_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::BY_KW)
     }
     #[inline]
-    pub fn create_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CREATE_KW)
+    pub fn owned_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OWNED_KW)
     }
     #[inline]
-    pub fn delete_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DELETE_KW)
+    pub fn reassign_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REASSIGN_KW)
     }
     #[inline]
-    pub fn execute_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EXECUTE_KW)
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ReferencesConstraint {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ReferencesConstraint {
     #[inline]
-    pub fn ident_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENT)
+    pub fn match_type(&self) -> Option<MatchType> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn insert_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INSERT_KW)
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn references_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REFERENCES_KW)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn select_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SELECT_KW)
+    pub fn on_delete_action(&self) -> Option<OnDeleteAction> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn system_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SYSTEM_KW)
+    pub fn on_update_action(&self) -> Option<OnUpdateAction> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn temp_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TEMP_KW)
+    pub fn path(&self) -> Option<Path> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn temporary_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TEMPORARY_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn trigger_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn truncate_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TRUNCATE_KW)
+    pub fn constraint_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
     }
     #[inline]
-    pub fn update_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::UPDATE_KW)
+    pub fn references_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REFERENCES_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RevokeCommandList {
+pub struct Referencing {
     pub(crate) syntax: SyntaxNode,
 }
-impl RevokeCommandList {
+impl Referencing {
     #[inline]
-    pub fn revoke_commands(&self) -> AstChildren<RevokeCommand> {
+    pub fn referencing_tables(&self) -> AstChildren<ReferencingTable> {
         support::children(&self.syntax)
     }
+    #[inline]
+    pub fn referencing_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REFERENCING_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RevokeDefaultPrivileges {
+pub struct ReferencingTable {
     pub(crate) syntax: SyntaxNode,
 }
-impl RevokeDefaultPrivileges {
-    #[inline]
-    pub fn privilege_target(&self) -> Option<PrivilegeTarget> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn privileges(&self) -> Option<Privileges> {
-        support::child(&self.syntax)
-    }
+impl ReferencingTable {
     #[inline]
-    pub fn role_list(&self) -> Option<RoleList> {
+    pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn cascade_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CASCADE_KW)
-    }
-    #[inline]
-    pub fn for_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FOR_KW)
-    }
-    #[inline]
-    pub fn from_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FROM_KW)
-    }
-    #[inline]
-    pub fn grant_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::GRANT_KW)
-    }
-    #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
     }
     #[inline]
-    pub fn option_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OPTION_KW)
+    pub fn new_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NEW_KW)
     }
     #[inline]
-    pub fn restrict_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
+    pub fn old_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OLD_KW)
     }
     #[inline]
-    pub fn revoke_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::REVOKE_KW)
+    pub fn table_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Role {
+pub struct Refresh {
     pub(crate) syntax: SyntaxNode,
 }
-impl Role {
+impl Refresh {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
+    pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn current_role_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CURRENT_ROLE_KW)
+    pub fn with_data(&self) -> Option<WithData> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn current_user_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CURRENT_USER_KW)
+    pub fn with_no_data(&self) -> Option<WithNoData> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn group_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::GROUP_KW)
+    pub fn concurrently_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW)
     }
     #[inline]
-    pub fn session_user_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SESSION_USER_KW)
+    pub fn materialized_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RoleList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl RoleList {
     #[inline]
-    pub fn roles(&self) -> AstChildren<Role> {
-        support::children(&self.syntax)
+    pub fn refresh_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REFRESH_KW)
+    }
+    #[inline]
+    pub fn view_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VIEW_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RoleOption {
+pub struct RefreshCollationVersion {
     pub(crate) syntax: SyntaxNode,
 }
-impl RoleOption {
+impl RefreshCollationVersion {
     #[inline]
-    pub fn inherit_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INHERIT_KW)
+    pub fn collation_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COLLATION_KW)
+    }
+    #[inline]
+    pub fn refresh_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REFRESH_KW)
+    }
+    #[inline]
+    pub fn version_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VERSION_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RoleOptionList {
+pub struct RefreshVersion {
     pub(crate) syntax: SyntaxNode,
 }
-impl RoleOptionList {
+impl RefreshVersion {
     #[inline]
-    pub fn role_options(&self) -> AstChildren<RoleOption> {
-        support::children(&self.syntax)
+    pub fn refresh_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REFRESH_KW)
     }
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn version_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VERSION_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Rollback {
+pub struct Reindex {
     pub(crate) syntax: SyntaxNode,
 }
-impl Rollback {
+impl Reindex {
     #[inline]
-    pub fn literal(&self) -> Option<Literal> {
+    pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn database_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DATABASE_KW)
     }
     #[inline]
-    pub fn abort_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ABORT_KW)
+    pub fn index_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INDEX_KW)
     }
     #[inline]
-    pub fn and_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AND_KW)
+    pub fn reindex_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REINDEX_KW)
     }
     #[inline]
-    pub fn chain_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CHAIN_KW)
+    pub fn schema_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
     }
     #[inline]
-    pub fn no_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NO_KW)
+    pub fn system_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SYSTEM_KW)
     }
     #[inline]
-    pub fn prepared_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PREPARED_KW)
+    pub fn table_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLE_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RelationName {
+    pub(crate) syntax: SyntaxNode,
+}
+impl RelationName {
     #[inline]
-    pub fn rollback_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ROLLBACK_KW)
+    pub fn path(&self) -> Option<Path> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn savepoint_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn transaction_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
+    pub fn star_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STAR)
     }
     #[inline]
-    pub fn work_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WORK_KW)
+    pub fn only_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ONLY_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Row {
+pub struct ReleaseSavepoint {
     pub(crate) syntax: SyntaxNode,
 }
-impl Row {
+impl ReleaseSavepoint {
     #[inline]
-    pub fn exprs(&self) -> AstChildren<Expr> {
-        support::children(&self.syntax)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RowList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl RowList {
     #[inline]
-    pub fn rows(&self) -> AstChildren<Row> {
-        support::children(&self.syntax)
+    pub fn release_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RELEASE_KW)
+    }
+    #[inline]
+    pub fn savepoint_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RowsFuncOption {
+pub struct RenameColumn {
     pub(crate) syntax: SyntaxNode,
 }
-impl RowsFuncOption {
+impl RenameColumn {
     #[inline]
-    pub fn rows_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ROWS_KW)
+    pub fn column_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COLUMN_KW)
+    }
+    #[inline]
+    pub fn rename_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RENAME_KW)
+    }
+    #[inline]
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Savepoint {
+pub struct RenameConstraint {
     pub(crate) syntax: SyntaxNode,
 }
-impl Savepoint {
+impl RenameConstraint {
     #[inline]
     pub fn name(&self) -> Option<Name> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn savepoint_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn constraint_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
+    }
+    #[inline]
+    pub fn rename_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RENAME_KW)
+    }
+    #[inline]
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SchemaAuthorization {
+pub struct RenameTo {
     pub(crate) syntax: SyntaxNode,
 }
-impl SchemaAuthorization {
+impl RenameTo {
     #[inline]
-    pub fn role(&self) -> Option<Role> {
+    pub fn name(&self) -> Option<Name> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn authorization_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW)
+    pub fn rename_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RENAME_KW)
+    }
+    #[inline]
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SecurityFuncOption {
+pub struct RepeatableClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl SecurityFuncOption {
+impl RepeatableClause {
     #[inline]
-    pub fn definer_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFINER_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn invoker_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INVOKER_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn security_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SECURITY_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn repeatable_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REPEATABLE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SecurityLabel {
+pub struct RepeatableRead {
     pub(crate) syntax: SyntaxNode,
 }
-impl SecurityLabel {
+impl RepeatableRead {
     #[inline]
-    pub fn aggregate(&self) -> Option<Aggregate> {
-        support::child(&self.syntax)
+    pub fn isolation_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
     }
     #[inline]
-    pub fn for_provider(&self) -> Option<ForProvider> {
-        support::child(&self.syntax)
+    pub fn level_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LEVEL_KW)
     }
     #[inline]
-    pub fn function_sig(&self) -> Option<FunctionSig> {
-        support::child(&self.syntax)
+    pub fn read_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::READ_KW)
     }
     #[inline]
-    pub fn literal(&self) -> Option<Literal> {
-        support::child(&self.syntax)
+    pub fn repeatable_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REPEATABLE_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ReplicaIdentity {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ReplicaIdentity {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
+    pub fn identity_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
     }
     #[inline]
-    pub fn aggregate_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AGGREGATE_KW)
+    pub fn replica_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REPLICA_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Reset {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Reset {
     #[inline]
-    pub fn column_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COLUMN_KW)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn database_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DATABASE_KW)
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
     }
     #[inline]
-    pub fn domain_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DOMAIN_KW)
+    pub fn reset_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESET_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ResetConfigParam {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ResetConfigParam {
     #[inline]
-    pub fn event_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EVENT_KW)
+    pub fn path(&self) -> Option<Path> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn foreign_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
     }
     #[inline]
-    pub fn function_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
+    pub fn reset_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESET_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ResetFuncOption {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ResetFuncOption {
     #[inline]
-    pub fn is_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IS_KW)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn label_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LABEL_KW)
+    pub fn reset_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESET_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ResetOptions {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ResetOptions {
     #[inline]
-    pub fn language_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn large_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LARGE_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn materialized_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
+    pub fn reset_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESET_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ResetSessionAuth {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ResetSessionAuth {
     #[inline]
-    pub fn null_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    pub fn authorization_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW)
     }
     #[inline]
-    pub fn object_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OBJECT_KW)
+    pub fn reset_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESET_KW)
     }
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn session_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SESSION_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Restart {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Restart {
     #[inline]
-    pub fn procedural_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PROCEDURAL_KW)
+    pub fn restart_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTART_KW)
     }
     #[inline]
-    pub fn procedure_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PROCEDURE_KW)
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Restrict {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Restrict {
     #[inline]
-    pub fn publication_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PUBLICATION_KW)
+    pub fn restrict_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RetType {
+    pub(crate) syntax: SyntaxNode,
+}
+impl RetType {
     #[inline]
-    pub fn role_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ROLE_KW)
+    pub fn ty(&self) -> Option<Type> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn routine_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ROUTINE_KW)
+    pub fn returns_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RETURNS_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ReturnFuncOption {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ReturnFuncOption {
     #[inline]
-    pub fn schema_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn security_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SECURITY_KW)
+    pub fn return_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RETURN_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ReturningClause {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ReturningClause {
     #[inline]
-    pub fn sequence_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SEQUENCE_KW)
+    pub fn returning_option_list(&self) -> Option<ReturningOptionList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn subscription_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW)
+    pub fn target_list(&self) -> Option<TargetList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn table_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLE_KW)
+    pub fn returning_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RETURNING_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ReturningOption {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ReturningOption {
     #[inline]
-    pub fn tablespace_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn trigger_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
     }
     #[inline]
-    pub fn type_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TYPE_KW)
+    pub fn new_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NEW_KW)
     }
     #[inline]
-    pub fn view_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VIEW_KW)
+    pub fn old_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OLD_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Select {
+pub struct ReturningOptionList {
     pub(crate) syntax: SyntaxNode,
 }
-impl Select {
+impl ReturningOptionList {
     #[inline]
-    pub fn fetch_clause(&self) -> Option<FetchClause> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn filter_clause(&self) -> Option<FilterClause> {
-        support::child(&self.syntax)
+    pub fn returning_options(&self) -> AstChildren<ReturningOption> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn from_clause(&self) -> Option<FromClause> {
-        support::child(&self.syntax)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn group_by_clause(&self) -> Option<GroupByClause> {
-        support::child(&self.syntax)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn having_clause(&self) -> Option<HavingClause> {
-        support::child(&self.syntax)
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Revoke {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Revoke {
     #[inline]
-    pub fn limit_clause(&self) -> Option<LimitClause> {
-        support::child(&self.syntax)
+    pub fn name_refs(&self) -> AstChildren<NameRef> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn locking_clauses(&self) -> AstChildren<LockingClause> {
+    pub fn paths(&self) -> AstChildren<Path> {
         support::children(&self.syntax)
     }
     #[inline]
-    pub fn offset_clause(&self) -> Option<OffsetClause> {
+    pub fn revoke_command_list(&self) -> Option<RevokeCommandList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn order_by_clause(&self) -> Option<OrderByClause> {
+    pub fn role(&self) -> Option<Role> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn select_clause(&self) -> Option<SelectClause> {
+    pub fn role_list(&self) -> Option<RoleList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn where_clause(&self) -> Option<WhereClause> {
-        support::child(&self.syntax)
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
     }
     #[inline]
-    pub fn window_clause(&self) -> Option<WindowClause> {
-        support::child(&self.syntax)
+    pub fn by_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::BY_KW)
     }
     #[inline]
-    pub fn with_clause(&self) -> Option<WithClause> {
-        support::child(&self.syntax)
+    pub fn cascade_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CASCADE_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SelectClause {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SelectClause {
     #[inline]
-    pub fn distinct_clause(&self) -> Option<DistinctClause> {
-        support::child(&self.syntax)
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
     }
     #[inline]
-    pub fn target_list(&self) -> Option<TargetList> {
-        support::child(&self.syntax)
+    pub fn from_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FROM_KW)
     }
     #[inline]
-    pub fn all_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    pub fn grant_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::GRANT_KW)
     }
     #[inline]
-    pub fn select_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SELECT_KW)
+    pub fn granted_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::GRANTED_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SelectInto {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SelectInto {
     #[inline]
-    pub fn filter_clause(&self) -> Option<FilterClause> {
-        support::child(&self.syntax)
+    pub fn in_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IN_KW)
     }
     #[inline]
-    pub fn from_clause(&self) -> Option<FromClause> {
-        support::child(&self.syntax)
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
     #[inline]
-    pub fn group_by_clause(&self) -> Option<GroupByClause> {
-        support::child(&self.syntax)
+    pub fn option_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OPTION_KW)
     }
     #[inline]
-    pub fn having_clause(&self) -> Option<HavingClause> {
-        support::child(&self.syntax)
+    pub fn privileges_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PRIVILEGES_KW)
     }
     #[inline]
-    pub fn into_clause(&self) -> Option<IntoClause> {
-        support::child(&self.syntax)
+    pub fn restrict_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
     }
     #[inline]
-    pub fn limit_clause(&self) -> Option<LimitClause> {
-        support::child(&self.syntax)
+    pub fn revoke_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REVOKE_KW)
     }
     #[inline]
-    pub fn locking_clauses(&self) -> AstChildren<LockingClause> {
-        support::children(&self.syntax)
+    pub fn schema_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
     }
     #[inline]
-    pub fn offset_clause(&self) -> Option<OffsetClause> {
-        support::child(&self.syntax)
+    pub fn table_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLE_KW)
     }
     #[inline]
-    pub fn order_by_clause(&self) -> Option<OrderByClause> {
-        support::child(&self.syntax)
+    pub fn tables_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLES_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RevokeCommand {
+    pub(crate) syntax: SyntaxNode,
+}
+impl RevokeCommand {
     #[inline]
-    pub fn select_clause(&self) -> Option<SelectClause> {
+    pub fn role(&self) -> Option<Role> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn where_clause(&self) -> Option<WhereClause> {
-        support::child(&self.syntax)
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
     }
     #[inline]
-    pub fn window_clause(&self) -> Option<WindowClause> {
-        support::child(&self.syntax)
+    pub fn alter_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALTER_KW)
     }
     #[inline]
-    pub fn with_clause(&self) -> Option<WithClause> {
-        support::child(&self.syntax)
+    pub fn create_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CREATE_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SequenceOption {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SequenceOption {
     #[inline]
-    pub fn cycle_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CYCLE_KW)
+    pub fn delete_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DELETE_KW)
     }
     #[inline]
-    pub fn maxvalue_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MAXVALUE_KW)
+    pub fn execute_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EXECUTE_KW)
     }
     #[inline]
-    pub fn minvalue_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::MINVALUE_KW)
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
     }
     #[inline]
-    pub fn no_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NO_KW)
+    pub fn insert_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INSERT_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SequenceOptionList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SequenceOptionList {
     #[inline]
-    pub fn sequence_options(&self) -> AstChildren<SequenceOption> {
-        support::children(&self.syntax)
+    pub fn references_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REFERENCES_KW)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn select_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SELECT_KW)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn system_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SYSTEM_KW)
+    }
+    #[inline]
+    pub fn temp_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TEMP_KW)
+    }
+    #[inline]
+    pub fn temporary_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TEMPORARY_KW)
+    }
+    #[inline]
+    pub fn trigger_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
+    }
+    #[inline]
+    pub fn truncate_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRUNCATE_KW)
+    }
+    #[inline]
+    pub fn update_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UPDATE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Serializable {
+pub struct RevokeCommandList {
     pub(crate) syntax: SyntaxNode,
 }
-impl Serializable {
-    #[inline]
-    pub fn isolation_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
-    }
-    #[inline]
-    pub fn level_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LEVEL_KW)
-    }
+impl RevokeCommandList {
     #[inline]
-    pub fn serializable_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SERIALIZABLE_KW)
+    pub fn revoke_commands(&self) -> AstChildren<RevokeCommand> {
+        support::children(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Set {
+pub struct RevokeDefaultPrivileges {
     pub(crate) syntax: SyntaxNode,
 }
-impl Set {
+impl RevokeDefaultPrivileges {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
+    pub fn privilege_target(&self) -> Option<PrivilegeTarget> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn path(&self) -> Option<Path> {
+    pub fn privileges(&self) -> Option<Privileges> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn eq_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EQ)
+    pub fn role_list(&self) -> Option<RoleList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn default_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    pub fn cascade_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CASCADE_KW)
     }
     #[inline]
-    pub fn local_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LOCAL_KW)
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
     }
     #[inline]
-    pub fn session_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SESSION_KW)
+    pub fn from_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FROM_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn grant_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::GRANT_KW)
     }
     #[inline]
-    pub fn time_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TIME_KW)
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
     #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn option_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OPTION_KW)
     }
     #[inline]
-    pub fn zone_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ZONE_KW)
+    pub fn restrict_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetAccessMethod {
+    #[inline]
+    pub fn revoke_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REVOKE_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Role {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetAccessMethod {
+impl Role {
     #[inline]
     pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn access_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ACCESS_KW)
-    }
-    #[inline]
-    pub fn method_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::METHOD_KW)
+    pub fn current_role_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CURRENT_ROLE_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn current_user_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CURRENT_USER_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetClause {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetClause {
     #[inline]
-    pub fn set_column_list(&self) -> Option<SetColumnList> {
-        support::child(&self.syntax)
+    pub fn group_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::GROUP_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn session_user_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SESSION_USER_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetColumnList {
+pub struct RoleList {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetColumnList {
+impl RoleList {
     #[inline]
-    pub fn set_columns(&self) -> AstChildren<SetColumn> {
+    pub fn roles(&self) -> AstChildren<Role> {
         support::children(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetCompression {
+pub struct RoleOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetCompression {
-    #[inline]
-    pub fn compression_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COMPRESSION_KW)
-    }
+impl RoleOption {
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn inherit_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INHERIT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetConfigParam {
+pub struct RoleOptionList {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetConfigParam {
+impl RoleOptionList {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
+    pub fn role_options(&self) -> AstChildren<RoleOption> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetConstraints {
+pub struct Rollback {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetConstraints {
+impl Rollback {
     #[inline]
-    pub fn paths(&self) -> AstChildren<Path> {
-        support::children(&self.syntax)
+    pub fn literal(&self) -> Option<Literal> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn all_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn constraints_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONSTRAINTS_KW)
+    pub fn abort_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ABORT_KW)
     }
     #[inline]
-    pub fn deferred_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFERRED_KW)
+    pub fn and_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AND_KW)
     }
     #[inline]
-    pub fn immediate_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IMMEDIATE_KW)
+    pub fn chain_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CHAIN_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn no_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NO_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetDefault {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetDefault {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
+    pub fn prepared_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PREPARED_KW)
     }
     #[inline]
-    pub fn default_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    pub fn rollback_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROLLBACK_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn savepoint_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetDefaultColumns {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetDefaultColumns {
     #[inline]
-    pub fn column_list(&self) -> Option<ColumnList> {
-        support::child(&self.syntax)
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
     }
     #[inline]
-    pub fn default_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    pub fn transaction_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn work_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WORK_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetExpr {
+pub struct Row {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetExpr {
-    #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+impl Row {
     #[inline]
-    pub fn default_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    pub fn exprs(&self) -> AstChildren<Expr> {
+        support::children(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetExprList {
+pub struct RowList {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetExprList {
+impl RowList {
     #[inline]
-    pub fn set_exprs(&self) -> AstChildren<SetExpr> {
+    pub fn rows(&self) -> AstChildren<Row> {
         support::children(&self.syntax)
     }
-    #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
-    }
-    #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
-    }
-    #[inline]
-    pub fn row_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ROW_KW)
-    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetExpression {
+pub struct RowsFuncOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetExpression {
-    #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn expression_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EXPRESSION_KW)
-    }
+impl RowsFuncOption {
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn rows_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROWS_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetFuncOption {
+pub struct Savepoint {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetFuncOption {
+impl Savepoint {
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetGenerated {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetGenerated {
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn savepoint_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetGeneratedOptions {
+pub struct SchemaAuthorization {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetGeneratedOptions {
+impl SchemaAuthorization {
     #[inline]
-    pub fn generated_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::GENERATED_KW)
+    pub fn role(&self) -> Option<Role> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn authorization_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetLogged {
+pub struct SecurityFuncOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetLogged {
+impl SecurityFuncOption {
     #[inline]
-    pub fn logged_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LOGGED_KW)
+    pub fn definer_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFINER_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn invoker_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INVOKER_KW)
+    }
+    #[inline]
+    pub fn security_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SECURITY_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetMultipleColumns {
+pub struct SecurityLabel {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetMultipleColumns {
+impl SecurityLabel {
     #[inline]
-    pub fn column_list(&self) -> Option<ColumnList> {
+    pub fn aggregate(&self) -> Option<Aggregate> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn paren_select(&self) -> Option<ParenSelect> {
+    pub fn for_provider(&self) -> Option<ForProvider> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn set_expr_list(&self) -> Option<SetExprList> {
+    pub fn function_sig(&self) -> Option<FunctionSig> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn eq_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EQ)
+    pub fn literal(&self) -> Option<Literal> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetNotNull {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetNotNull {
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn path(&self) -> Option<Path> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn null_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    pub fn aggregate_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AGGREGATE_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn column_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COLUMN_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetNullColumns {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetNullColumns {
     #[inline]
-    pub fn column_list(&self) -> Option<ColumnList> {
-        support::child(&self.syntax)
+    pub fn database_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DATABASE_KW)
     }
     #[inline]
-    pub fn null_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    pub fn domain_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DOMAIN_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn event_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EVENT_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetOptions {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetOptions {
     #[inline]
-    pub fn attribute_list(&self) -> Option<AttributeList> {
-        support::child(&self.syntax)
+    pub fn foreign_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn function_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetOptionsList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetOptionsList {
     #[inline]
-    pub fn alter_option_list(&self) -> Option<AlterOptionList> {
-        support::child(&self.syntax)
+    pub fn is_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IS_KW)
     }
     #[inline]
-    pub fn options_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OPTIONS_KW)
+    pub fn label_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LABEL_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn language_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetRole {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetRole {
     #[inline]
-    pub fn role(&self) -> Option<Role> {
-        support::child(&self.syntax)
+    pub fn large_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LARGE_KW)
     }
     #[inline]
-    pub fn local_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LOCAL_KW)
+    pub fn materialized_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
     }
     #[inline]
-    pub fn none_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NONE_KW)
+    pub fn null_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULL_KW)
     }
     #[inline]
-    pub fn reset_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESET_KW)
+    pub fn object_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OBJECT_KW)
     }
     #[inline]
-    pub fn role_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ROLE_KW)
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
     }
     #[inline]
-    pub fn session_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SESSION_KW)
+    pub fn procedural_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PROCEDURAL_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn procedure_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PROCEDURE_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetSchema {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetSchema {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn publication_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PUBLICATION_KW)
+    }
+    #[inline]
+    pub fn role_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROLE_KW)
+    }
+    #[inline]
+    pub fn routine_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROUTINE_KW)
     }
     #[inline]
     pub fn schema_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn security_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SECURITY_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetSequenceOption {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetSequenceOption {
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn sequence_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SEQUENCE_KW)
+    }
+    #[inline]
+    pub fn subscription_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW)
+    }
+    #[inline]
+    pub fn table_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLE_KW)
+    }
+    #[inline]
+    pub fn tablespace_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
+    }
+    #[inline]
+    pub fn trigger_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
+    }
+    #[inline]
+    pub fn type_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TYPE_KW)
+    }
+    #[inline]
+    pub fn view_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VIEW_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetSessionAuth {
+pub struct Select {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetSessionAuth {
+impl Select {
     #[inline]
-    pub fn literal(&self) -> Option<Literal> {
+    pub fn fetch_clause(&self) -> Option<FetchClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn role(&self) -> Option<Role> {
+    pub fn filter_clause(&self) -> Option<FilterClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn authorization_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW)
+    pub fn from_clause(&self) -> Option<FromClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn default_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    pub fn group_by_clause(&self) -> Option<GroupByClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn local_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::LOCAL_KW)
+    pub fn having_clause(&self) -> Option<HavingClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn session_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SESSION_KW)
+    pub fn limit_clause(&self) -> Option<LimitClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn locking_clauses(&self) -> AstChildren<LockingClause> {
+        support::children(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetSingleColumn {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetSingleColumn {
     #[inline]
-    pub fn column(&self) -> Option<Column> {
+    pub fn offset_clause(&self) -> Option<OffsetClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn set_expr(&self) -> Option<SetExpr> {
+    pub fn order_by_clause(&self) -> Option<OrderByClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn eq_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EQ)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetStatistics {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetStatistics {
-    #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn select_clause(&self) -> Option<SelectClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn statistics_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::STATISTICS_KW)
+    pub fn where_clause(&self) -> Option<WhereClause> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetStorage {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetStorage {
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn window_clause(&self) -> Option<WindowClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn storage_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::STORAGE_KW)
+    pub fn with_clause(&self) -> Option<WithClause> {
+        support::child(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetTablespace {
+pub struct SelectClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetTablespace {
+impl SelectClause {
     #[inline]
-    pub fn path(&self) -> Option<Path> {
+    pub fn distinct_clause(&self) -> Option<DistinctClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn target_list(&self) -> Option<TargetList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn tablespace_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
+    }
+    #[inline]
+    pub fn select_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SELECT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetTransaction {
+pub struct SelectInto {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetTransaction {
+impl SelectInto {
     #[inline]
-    pub fn literal(&self) -> Option<Literal> {
+    pub fn filter_clause(&self) -> Option<FilterClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn transaction_mode_list(&self) -> Option<TransactionModeList> {
+    pub fn from_clause(&self) -> Option<FromClause> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn as_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AS_KW)
+    pub fn group_by_clause(&self) -> Option<GroupByClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn characteristics_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CHARACTERISTICS_KW)
-    }
+    pub fn having_clause(&self) -> Option<HavingClause> {
+        support::child(&self.syntax)
+    }
     #[inline]
-    pub fn session_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SESSION_KW)
+    pub fn into_clause(&self) -> Option<IntoClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn limit_clause(&self) -> Option<LimitClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn snapshot_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SNAPSHOT_KW)
+    pub fn locking_clauses(&self) -> AstChildren<LockingClause> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn transaction_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
+    pub fn offset_clause(&self) -> Option<OffsetClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn order_by_clause(&self) -> Option<OrderByClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn select_clause(&self) -> Option<SelectClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn where_clause(&self) -> Option<WhereClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn window_clause(&self) -> Option<WindowClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn with_clause(&self) -> Option<WithClause> {
+        support::child(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetType {
+pub struct SequenceOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl SetType {
+impl SequenceOption {
     #[inline]
-    pub fn collate(&self) -> Option<Collate> {
+    pub fn literal(&self) -> Option<Literal> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
@@ -12923,290 +13492,326 @@ impl SetType {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
     }
     #[inline]
-    pub fn type_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TYPE_KW)
+    pub fn by_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::BY_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetUnlogged {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetUnlogged {
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn cycle_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CYCLE_KW)
     }
     #[inline]
-    pub fn unlogged_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::UNLOGGED_KW)
+    pub fn increment_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INCREMENT_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetWithoutCluster {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetWithoutCluster {
     #[inline]
-    pub fn cluster_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CLUSTER_KW)
+    pub fn logged_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LOGGED_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn maxvalue_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MAXVALUE_KW)
     }
     #[inline]
-    pub fn without_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
+    pub fn minvalue_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MINVALUE_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SetWithoutOids {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SetWithoutOids {
     #[inline]
-    pub fn oids_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OIDS_KW)
+    pub fn name_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NAME_KW)
     }
     #[inline]
-    pub fn set_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SET_KW)
+    pub fn no_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NO_KW)
     }
     #[inline]
-    pub fn without_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
+    pub fn none_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NONE_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Show {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Show {
     #[inline]
-    pub fn show_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SHOW_KW)
+    pub fn owned_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OWNED_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SimilarTo {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SimilarTo {
     #[inline]
-    pub fn similar_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SIMILAR_KW)
+    pub fn restart_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTART_KW)
     }
     #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn sequence_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SEQUENCE_KW)
+    }
+    #[inline]
+    pub fn start_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::START_KW)
+    }
+    #[inline]
+    pub fn unlogged_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UNLOGGED_KW)
+    }
+    #[inline]
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SliceExpr {
+pub struct SequenceOptionList {
     pub(crate) syntax: SyntaxNode,
 }
-impl SliceExpr {
+impl SequenceOptionList {
     #[inline]
-    pub fn l_brack_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_BRACK)
+    pub fn sequence_options(&self) -> AstChildren<SequenceOption> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn r_brack_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_BRACK)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn colon_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::COLON)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SortAsc {
+pub struct Serializable {
     pub(crate) syntax: SyntaxNode,
 }
-impl SortAsc {
+impl Serializable {
     #[inline]
-    pub fn asc_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ASC_KW)
+    pub fn isolation_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
+    }
+    #[inline]
+    pub fn level_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LEVEL_KW)
+    }
+    #[inline]
+    pub fn serializable_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SERIALIZABLE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SortBy {
+pub struct Set {
     pub(crate) syntax: SyntaxNode,
 }
-impl SortBy {
+impl Set {
     #[inline]
     pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn nulls_first(&self) -> Option<NullsFirst> {
+    pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn nulls_last(&self) -> Option<NullsLast> {
-        support::child(&self.syntax)
+    pub fn eq_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EQ)
     }
     #[inline]
-    pub fn sort_asc(&self) -> Option<SortAsc> {
-        support::child(&self.syntax)
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
     }
     #[inline]
-    pub fn sort_desc(&self) -> Option<SortDesc> {
-        support::child(&self.syntax)
+    pub fn local_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LOCAL_KW)
     }
     #[inline]
-    pub fn sort_using(&self) -> Option<SortUsing> {
-        support::child(&self.syntax)
+    pub fn session_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SESSION_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SortByList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl SortByList {
     #[inline]
-    pub fn sort_bys(&self) -> AstChildren<SortBy> {
-        support::children(&self.syntax)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
+    }
+    #[inline]
+    pub fn time_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TIME_KW)
+    }
+    #[inline]
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
+    }
+    #[inline]
+    pub fn zone_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ZONE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SortDesc {
+pub struct SetAccessMethod {
     pub(crate) syntax: SyntaxNode,
 }
-impl SortDesc {
+impl SetAccessMethod {
     #[inline]
-    pub fn desc_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DESC_KW)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn access_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ACCESS_KW)
+    }
+    #[inline]
+    pub fn method_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::METHOD_KW)
+    }
+    #[inline]
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SortUsing {
+pub struct SetClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl SortUsing {
+impl SetClause {
     #[inline]
-    pub fn op(&self) -> Option<Op> {
+    pub fn set_column_list(&self) -> Option<SetColumnList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn using_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::USING_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SourceFile {
+pub struct SetColumnList {
     pub(crate) syntax: SyntaxNode,
 }
-impl SourceFile {
+impl SetColumnList {
     #[inline]
-    pub fn stmts(&self) -> AstChildren<Stmt> {
+    pub fn set_columns(&self) -> AstChildren<SetColumn> {
         support::children(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Storage {
+pub struct SetCompression {
     pub(crate) syntax: SyntaxNode,
 }
-impl Storage {
+impl SetCompression {
     #[inline]
-    pub fn default_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    pub fn compression_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMPRESSION_KW)
     }
     #[inline]
-    pub fn external_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::EXTERNAL_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SetConfigParam {
+    pub(crate) syntax: SyntaxNode,
+}
+impl SetConfigParam {
     #[inline]
-    pub fn ident_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENT)
+    pub fn path(&self) -> Option<Path> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn storage_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::STORAGE_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct StrictFuncOption {
+pub struct SetConstraints {
     pub(crate) syntax: SyntaxNode,
 }
-impl StrictFuncOption {
+impl SetConstraints {
     #[inline]
-    pub fn called_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CALLED_KW)
+    pub fn paths(&self) -> AstChildren<Path> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn input_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INPUT_KW)
+    pub fn all_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ALL_KW)
     }
     #[inline]
-    pub fn null_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    pub fn constraints_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONSTRAINTS_KW)
     }
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn deferred_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFERRED_KW)
     }
     #[inline]
-    pub fn returns_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RETURNS_KW)
+    pub fn immediate_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IMMEDIATE_KW)
     }
     #[inline]
-    pub fn strict_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::STRICT_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SupportFuncOption {
+pub struct SetDefault {
     pub(crate) syntax: SyntaxNode,
 }
-impl SupportFuncOption {
+impl SetDefault {
     #[inline]
-    pub fn support_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SUPPORT_KW)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    }
+    #[inline]
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Table {
+pub struct SetDefaultColumns {
     pub(crate) syntax: SyntaxNode,
 }
-impl Table {
+impl SetDefaultColumns {
     #[inline]
-    pub fn relation_name(&self) -> Option<RelationName> {
+    pub fn column_list(&self) -> Option<ColumnList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn table_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLE_KW)
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    }
+    #[inline]
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TableArgList {
+pub struct SetExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl TableArgList {
+impl SetExpr {
     #[inline]
-    pub fn args(&self) -> AstChildren<TableArg> {
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SetExprList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl SetExprList {
+    #[inline]
+    pub fn set_exprs(&self) -> AstChildren<SetExpr> {
         support::children(&self.syntax)
     }
     #[inline]
@@ -13217,739 +13822,689 @@ impl TableArgList {
     pub fn r_paren_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
+    #[inline]
+    pub fn row_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROW_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TableList {
+pub struct SetExpression {
     pub(crate) syntax: SyntaxNode,
 }
-impl TableList {
+impl SetExpression {
     #[inline]
-    pub fn relation_names(&self) -> AstChildren<RelationName> {
-        support::children(&self.syntax)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn expression_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EXPRESSION_KW)
+    }
+    #[inline]
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Tablespace {
+pub struct SetFuncOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl Tablespace {
-    #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
-    }
+impl SetFuncOption {
     #[inline]
-    pub fn tablespace_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Target {
+pub struct SetGenerated {
     pub(crate) syntax: SyntaxNode,
 }
-impl Target {
+impl SetGenerated {
     #[inline]
-    pub fn as_name(&self) -> Option<AsName> {
-        support::child(&self.syntax)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SetGeneratedOptions {
+    pub(crate) syntax: SyntaxNode,
+}
+impl SetGeneratedOptions {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
+    pub fn generated_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::GENERATED_KW)
     }
     #[inline]
-    pub fn star_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::STAR)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TargetList {
+pub struct SetLogged {
     pub(crate) syntax: SyntaxNode,
 }
-impl TargetList {
+impl SetLogged {
     #[inline]
-    pub fn targets(&self) -> AstChildren<Target> {
-        support::children(&self.syntax)
+    pub fn logged_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LOGGED_KW)
+    }
+    #[inline]
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TimeType {
+pub struct SetMultipleColumns {
     pub(crate) syntax: SyntaxNode,
 }
-impl TimeType {
+impl SetMultipleColumns {
     #[inline]
-    pub fn literal(&self) -> Option<Literal> {
+    pub fn column_list(&self) -> Option<ColumnList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn timezone(&self) -> Option<Timezone> {
+    pub fn paren_select(&self) -> Option<ParenSelect> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn set_expr_list(&self) -> Option<SetExprList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn eq_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EQ)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SetNotNull {
+    pub(crate) syntax: SyntaxNode,
+}
+impl SetNotNull {
     #[inline]
-    pub fn time_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TIME_KW)
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
     }
     #[inline]
-    pub fn timestamp_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TIMESTAMP_KW)
+    pub fn null_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    }
+    #[inline]
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Timing {
+pub struct SetNullColumns {
     pub(crate) syntax: SyntaxNode,
 }
-impl Timing {
-    #[inline]
-    pub fn after_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AFTER_KW)
-    }
+impl SetNullColumns {
     #[inline]
-    pub fn before_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::BEFORE_KW)
+    pub fn column_list(&self) -> Option<ColumnList> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn instead_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INSTEAD_KW)
+    pub fn null_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULL_KW)
     }
     #[inline]
-    pub fn of_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OF_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TransactionModeList {
+pub struct SetOptions {
     pub(crate) syntax: SyntaxNode,
 }
-impl TransactionModeList {
+impl SetOptions {
     #[inline]
-    pub fn transaction_modes(&self) -> AstChildren<TransactionMode> {
-        support::children(&self.syntax)
+    pub fn attribute_list(&self) -> Option<AttributeList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TransformFromFunc {
+pub struct SetOptionsList {
     pub(crate) syntax: SyntaxNode,
 }
-impl TransformFromFunc {
+impl SetOptionsList {
     #[inline]
-    pub fn function_sig(&self) -> Option<FunctionSig> {
+    pub fn alter_option_list(&self) -> Option<AlterOptionList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn from_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FROM_KW)
+    pub fn options_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OPTIONS_KW)
     }
     #[inline]
-    pub fn function_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
-    }
-    #[inline]
-    pub fn sql_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SQL_KW)
-    }
-    #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TransformFuncOption {
+pub struct SetRole {
     pub(crate) syntax: SyntaxNode,
 }
-impl TransformFuncOption {
+impl SetRole {
     #[inline]
-    pub fn transform_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TRANSFORM_KW)
+    pub fn role(&self) -> Option<Role> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TransformToFunc {
-    pub(crate) syntax: SyntaxNode,
-}
-impl TransformToFunc {
     #[inline]
-    pub fn function_sig(&self) -> Option<FunctionSig> {
-        support::child(&self.syntax)
+    pub fn local_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LOCAL_KW)
     }
     #[inline]
-    pub fn function_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
+    pub fn none_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NONE_KW)
     }
     #[inline]
-    pub fn sql_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::SQL_KW)
+    pub fn reset_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESET_KW)
     }
     #[inline]
-    pub fn to_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TO_KW)
+    pub fn role_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROLE_KW)
     }
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn session_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SESSION_KW)
+    }
+    #[inline]
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TriggerEvent {
+pub struct SetSchema {
     pub(crate) syntax: SyntaxNode,
 }
-impl TriggerEvent {
+impl SetSchema {
     #[inline]
-    pub fn trigger_event_update(&self) -> Option<TriggerEventUpdate> {
+    pub fn name_ref(&self) -> Option<NameRef> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn delete_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DELETE_KW)
-    }
-    #[inline]
-    pub fn insert_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INSERT_KW)
-    }
-    #[inline]
-    pub fn truncate_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TRUNCATE_KW)
+    pub fn schema_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TriggerEventList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl TriggerEventList {
     #[inline]
-    pub fn trigger_events(&self) -> AstChildren<TriggerEvent> {
-        support::children(&self.syntax)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TriggerEventUpdate {
+pub struct SetSequenceOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl TriggerEventUpdate {
-    #[inline]
-    pub fn name_refs(&self) -> AstChildren<NameRef> {
-        support::children(&self.syntax)
-    }
-    #[inline]
-    pub fn of_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OF_KW)
-    }
+impl SetSequenceOption {
     #[inline]
-    pub fn update_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::UPDATE_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Truncate {
+pub struct SetSessionAuth {
     pub(crate) syntax: SyntaxNode,
 }
-impl Truncate {
+impl SetSessionAuth {
     #[inline]
-    pub fn table_list(&self) -> Option<TableList> {
+    pub fn literal(&self) -> Option<Literal> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn cascade_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CASCADE_KW)
-    }
-    #[inline]
-    pub fn continue_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONTINUE_KW)
+    pub fn role(&self) -> Option<Role> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn identity_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
+    pub fn authorization_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW)
     }
     #[inline]
-    pub fn restart_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESTART_KW)
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
     }
     #[inline]
-    pub fn restrict_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
+    pub fn local_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LOCAL_KW)
     }
     #[inline]
-    pub fn table_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TABLE_KW)
+    pub fn session_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SESSION_KW)
     }
     #[inline]
-    pub fn truncate_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TRUNCATE_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TupleExpr {
+pub struct SetSingleColumn {
     pub(crate) syntax: SyntaxNode,
 }
-impl TupleExpr {
+impl SetSingleColumn {
     #[inline]
-    pub fn exprs(&self) -> AstChildren<Expr> {
-        support::children(&self.syntax)
+    pub fn column(&self) -> Option<Column> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn set_expr(&self) -> Option<SetExpr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn eq_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EQ)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UnicodeNormalForm {
+pub struct SetStatistics {
     pub(crate) syntax: SyntaxNode,
 }
-impl UnicodeNormalForm {
-    #[inline]
-    pub fn nfc_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NFC_KW)
-    }
-    #[inline]
-    pub fn nfd_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NFD_KW)
-    }
+impl SetStatistics {
     #[inline]
-    pub fn nfkc_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NFKC_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
     #[inline]
-    pub fn nfkd_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NFKD_KW)
+    pub fn statistics_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STATISTICS_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UniqueConstraint {
+pub struct SetStorage {
     pub(crate) syntax: SyntaxNode,
 }
-impl UniqueConstraint {
-    #[inline]
-    pub fn column_list(&self) -> Option<ColumnList> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn name(&self) -> Option<Name> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn nulls_distinct(&self) -> Option<NullsDistinct> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn nulls_not_distinct(&self) -> Option<NullsNotDistinct> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn using_index(&self) -> Option<UsingIndex> {
-        support::child(&self.syntax)
-    }
+impl SetStorage {
     #[inline]
-    pub fn constraint_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
     #[inline]
-    pub fn unique_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::UNIQUE_KW)
+    pub fn storage_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STORAGE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Unlisten {
+pub struct SetTablespace {
     pub(crate) syntax: SyntaxNode,
 }
-impl Unlisten {
+impl SetTablespace {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
+    pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn star_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::STAR)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
     #[inline]
-    pub fn unlisten_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::UNLISTEN_KW)
+    pub fn tablespace_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Update {
+pub struct SetTransaction {
     pub(crate) syntax: SyntaxNode,
 }
-impl Update {
+impl SetTransaction {
     #[inline]
-    pub fn alias(&self) -> Option<Alias> {
+    pub fn literal(&self) -> Option<Literal> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn from_clause(&self) -> Option<FromClause> {
+    pub fn transaction_mode_list(&self) -> Option<TransactionModeList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn relation_name(&self) -> Option<RelationName> {
-        support::child(&self.syntax)
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
     }
     #[inline]
-    pub fn returning_clause(&self) -> Option<ReturningClause> {
-        support::child(&self.syntax)
+    pub fn characteristics_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CHARACTERISTICS_KW)
     }
     #[inline]
-    pub fn set_clause(&self) -> Option<SetClause> {
-        support::child(&self.syntax)
+    pub fn session_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SESSION_KW)
     }
     #[inline]
-    pub fn where_clause(&self) -> Option<WhereClause> {
-        support::child(&self.syntax)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
     #[inline]
-    pub fn update_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::UPDATE_KW)
+    pub fn snapshot_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SNAPSHOT_KW)
+    }
+    #[inline]
+    pub fn transaction_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UsingClause {
+pub struct SetType {
     pub(crate) syntax: SyntaxNode,
 }
-impl UsingClause {
+impl SetType {
     #[inline]
-    pub fn from_items(&self) -> AstChildren<FromItem> {
-        support::children(&self.syntax)
+    pub fn collate(&self) -> Option<Collate> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn using_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::USING_KW)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UsingIndex {
-    pub(crate) syntax: SyntaxNode,
-}
-impl UsingIndex {
-    #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn ty(&self) -> Option<Type> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn index_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::INDEX_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
     #[inline]
-    pub fn using_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::USING_KW)
+    pub fn type_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TYPE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UsingMethod {
+pub struct SetUnlogged {
     pub(crate) syntax: SyntaxNode,
 }
-impl UsingMethod {
+impl SetUnlogged {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
     #[inline]
-    pub fn using_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::USING_KW)
+    pub fn unlogged_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UNLOGGED_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UsingOnClause {
+pub struct SetWithoutCluster {
     pub(crate) syntax: SyntaxNode,
 }
-impl UsingOnClause {
-    #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+impl SetWithoutCluster {
     #[inline]
-    pub fn from_item(&self) -> Option<FromItem> {
-        support::child(&self.syntax)
+    pub fn cluster_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CLUSTER_KW)
     }
     #[inline]
-    pub fn on_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ON_KW)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
     #[inline]
-    pub fn using_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::USING_KW)
+    pub fn without_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Vacuum {
+pub struct SetWithoutOids {
     pub(crate) syntax: SyntaxNode,
 }
-impl Vacuum {
+impl SetWithoutOids {
     #[inline]
-    pub fn relation_name(&self) -> Option<RelationName> {
-        support::child(&self.syntax)
+    pub fn oids_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OIDS_KW)
     }
     #[inline]
-    pub fn vacuum_option_list(&self) -> Option<VacuumOptionList> {
-        support::child(&self.syntax)
+    pub fn set_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SET_KW)
     }
     #[inline]
-    pub fn vacuum_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VACUUM_KW)
+    pub fn without_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct VacuumOption {
+pub struct Show {
     pub(crate) syntax: SyntaxNode,
 }
-impl VacuumOption {
+impl Show {
     #[inline]
-    pub fn full_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FULL_KW)
+    pub fn show_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SHOW_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct VacuumOptionList {
+pub struct SimilarTo {
     pub(crate) syntax: SyntaxNode,
 }
-impl VacuumOptionList {
-    #[inline]
-    pub fn vacuum_options(&self) -> AstChildren<VacuumOption> {
-        support::children(&self.syntax)
-    }
+impl SimilarTo {
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn similar_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SIMILAR_KW)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ValidateConstraint {
+pub struct SliceExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl ValidateConstraint {
+impl SliceExpr {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn l_brack_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_BRACK)
     }
     #[inline]
-    pub fn constraint_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
+    pub fn r_brack_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_BRACK)
     }
     #[inline]
-    pub fn validate_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VALIDATE_KW)
+    pub fn colon_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COLON)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Values {
+pub struct SomeFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl Values {
+impl SomeFn {
     #[inline]
-    pub fn row_list(&self) -> Option<RowList> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn values_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VALUES_KW)
+    pub fn select_variant(&self) -> Option<SelectVariant> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn some_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SOME_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Variant {
+pub struct SortAsc {
     pub(crate) syntax: SyntaxNode,
 }
-impl Variant {
+impl SortAsc {
     #[inline]
-    pub fn literal(&self) -> Option<Literal> {
-        support::child(&self.syntax)
+    pub fn asc_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ASC_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct VariantList {
+pub struct SortBy {
     pub(crate) syntax: SyntaxNode,
 }
-impl VariantList {
+impl SortBy {
     #[inline]
-    pub fn variants(&self) -> AstChildren<Variant> {
-        support::children(&self.syntax)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn nulls_first(&self) -> Option<NullsFirst> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn nulls_last(&self) -> Option<NullsLast> {
+        support::child(&self.syntax)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct VolatilityFuncOption {
-    pub(crate) syntax: SyntaxNode,
-}
-impl VolatilityFuncOption {
     #[inline]
-    pub fn immutable_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IMMUTABLE_KW)
+    pub fn sort_asc(&self) -> Option<SortAsc> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn stable_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::STABLE_KW)
+    pub fn sort_desc(&self) -> Option<SortDesc> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn volatile_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::VOLATILE_KW)
+    pub fn sort_using(&self) -> Option<SortUsing> {
+        support::child(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WhenClause {
+pub struct SortByList {
     pub(crate) syntax: SyntaxNode,
 }
-impl WhenClause {
-    #[inline]
-    pub fn then_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::THEN_KW)
-    }
+impl SortByList {
     #[inline]
-    pub fn when_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WHEN_KW)
+    pub fn sort_bys(&self) -> AstChildren<SortBy> {
+        support::children(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WhenClauseList {
+pub struct SortDesc {
     pub(crate) syntax: SyntaxNode,
 }
-impl WhenClauseList {
-    #[inline]
-    pub fn when_clause(&self) -> Option<WhenClause> {
-        support::child(&self.syntax)
-    }
+impl SortDesc {
     #[inline]
-    pub fn when_clauses(&self) -> AstChildren<WhenClause> {
-        support::children(&self.syntax)
+    pub fn desc_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DESC_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WhenCondition {
+pub struct SortUsing {
     pub(crate) syntax: SyntaxNode,
 }
-impl WhenCondition {
+impl SortUsing {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
+    pub fn op(&self) -> Option<Op> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
-    }
-    #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
-    }
-    #[inline]
-    pub fn when_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WHEN_KW)
+    pub fn using_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::USING_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WhereClause {
+pub struct SourceFile {
     pub(crate) syntax: SyntaxNode,
 }
-impl WhereClause {
-    #[inline]
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+impl SourceFile {
     #[inline]
-    pub fn where_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WHERE_KW)
+    pub fn stmts(&self) -> AstChildren<Stmt> {
+        support::children(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WhereCurrentOf {
+pub struct Storage {
     pub(crate) syntax: SyntaxNode,
 }
-impl WhereCurrentOf {
+impl Storage {
     #[inline]
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
     }
     #[inline]
-    pub fn current_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::CURRENT_KW)
+    pub fn external_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EXTERNAL_KW)
     }
     #[inline]
-    pub fn of_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OF_KW)
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
     }
     #[inline]
-    pub fn where_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WHERE_KW)
+    pub fn storage_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STORAGE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WindowClause {
+pub struct StrictFuncOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl WindowClause {
+impl StrictFuncOption {
     #[inline]
-    pub fn window_defs(&self) -> AstChildren<WindowDef> {
-        support::children(&self.syntax)
+    pub fn called_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CALLED_KW)
     }
     #[inline]
-    pub fn window_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WINDOW_KW)
+    pub fn input_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INPUT_KW)
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WindowDef {
+    #[inline]
+    pub fn null_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    }
+    #[inline]
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
+    }
+    #[inline]
+    pub fn returns_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RETURNS_KW)
+    }
+    #[inline]
+    pub fn strict_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STRICT_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SubstringFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl WindowDef {
+impl SubstringFn {
     #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn window_spec(&self) -> Option<WindowSpec> {
-        support::child(&self.syntax)
+    pub fn exprs(&self) -> AstChildren<Expr> {
+        support::children(&self.syntax)
     }
     #[inline]
     pub fn l_paren_token(&self) -> Option<SyntaxToken> {
@@ -13960,163 +14515,154 @@ impl WindowDef {
         support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn as_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AS_KW)
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    }
+    #[inline]
+    pub fn from_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FROM_KW)
+    }
+    #[inline]
+    pub fn similar_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SIMILAR_KW)
+    }
+    #[inline]
+    pub fn substring_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SUBSTRING_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WindowFuncOption {
+pub struct SupportFuncOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl WindowFuncOption {
+impl SupportFuncOption {
     #[inline]
-    pub fn window_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WINDOW_KW)
+    pub fn support_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SUPPORT_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WindowSpec {
+pub struct Table {
     pub(crate) syntax: SyntaxNode,
 }
-impl WindowSpec {
-    #[inline]
-    pub fn exprs(&self) -> AstChildren<Expr> {
-        support::children(&self.syntax)
-    }
-    #[inline]
-    pub fn frame_clause(&self) -> Option<FrameClause> {
-        support::child(&self.syntax)
-    }
+impl Table {
     #[inline]
-    pub fn order_by_clause(&self) -> Option<OrderByClause> {
+    pub fn relation_name(&self) -> Option<RelationName> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn by_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::BY_KW)
-    }
-    #[inline]
-    pub fn ident_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENT)
-    }
-    #[inline]
-    pub fn partition_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PARTITION_KW)
+    pub fn table_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WithClause {
+pub struct TableArgList {
     pub(crate) syntax: SyntaxNode,
 }
-impl WithClause {
+impl TableArgList {
     #[inline]
-    pub fn with_tables(&self) -> AstChildren<WithTable> {
+    pub fn args(&self) -> AstChildren<TableArg> {
         support::children(&self.syntax)
     }
     #[inline]
-    pub fn recursive_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::RECURSIVE_KW)
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
     }
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WithData {
+pub struct TableList {
     pub(crate) syntax: SyntaxNode,
 }
-impl WithData {
-    #[inline]
-    pub fn data_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DATA_KW)
-    }
+impl TableList {
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn relation_names(&self) -> AstChildren<RelationName> {
+        support::children(&self.syntax)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WithNoData {
+pub struct TablesampleClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl WithNoData {
+impl TablesampleClause {
     #[inline]
-    pub fn data_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DATA_KW)
+    pub fn call_expr(&self) -> Option<CallExpr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn no_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NO_KW)
+    pub fn repeatable_clause(&self) -> Option<RepeatableClause> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn tablesample_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLESAMPLE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WithOptions {
+pub struct Tablespace {
     pub(crate) syntax: SyntaxNode,
 }
-impl WithOptions {
+impl Tablespace {
     #[inline]
-    pub fn options_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OPTIONS_KW)
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn tablespace_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WithParams {
+pub struct Target {
     pub(crate) syntax: SyntaxNode,
 }
-impl WithParams {
+impl Target {
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn as_name(&self) -> Option<AsName> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn star_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STAR)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WithTable {
+pub struct TargetList {
     pub(crate) syntax: SyntaxNode,
 }
-impl WithTable {
-    #[inline]
-    pub fn column_list(&self) -> Option<ColumnList> {
-        support::child(&self.syntax)
-    }
-    #[inline]
-    pub fn materialized(&self) -> Option<Materialized> {
-        support::child(&self.syntax)
-    }
+impl TargetList {
     #[inline]
-    pub fn name(&self) -> Option<Name> {
-        support::child(&self.syntax)
+    pub fn targets(&self) -> AstChildren<Target> {
+        support::children(&self.syntax)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TimeType {
+    pub(crate) syntax: SyntaxNode,
+}
+impl TimeType {
     #[inline]
-    pub fn not_materialized(&self) -> Option<NotMaterialized> {
+    pub fn literal(&self) -> Option<Literal> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn query(&self) -> Option<WithQuery> {
+    pub fn timezone(&self) -> Option<Timezone> {
         support::child(&self.syntax)
     }
     #[inline]
@@ -14128,730 +14674,2766 @@ impl WithTable {
         support::token(&self.syntax, SyntaxKind::R_PAREN)
     }
     #[inline]
-    pub fn as_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::AS_KW)
+    pub fn time_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TIME_KW)
+    }
+    #[inline]
+    pub fn timestamp_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TIMESTAMP_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WithTimezone {
+pub struct Timing {
     pub(crate) syntax: SyntaxNode,
 }
-impl WithTimezone {
+impl Timing {
     #[inline]
-    pub fn time_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TIME_KW)
+    pub fn after_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AFTER_KW)
     }
     #[inline]
-    pub fn with_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    pub fn before_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::BEFORE_KW)
     }
     #[inline]
-    pub fn zone_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ZONE_KW)
+    pub fn instead_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INSTEAD_KW)
+    }
+    #[inline]
+    pub fn of_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OF_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WithinClause {
+pub struct TransactionModeList {
     pub(crate) syntax: SyntaxNode,
 }
-impl WithinClause {
+impl TransactionModeList {
     #[inline]
-    pub fn order_by_clause(&self) -> Option<OrderByClause> {
+    pub fn transaction_modes(&self) -> AstChildren<TransactionMode> {
+        support::children(&self.syntax)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TransformFromFunc {
+    pub(crate) syntax: SyntaxNode,
+}
+impl TransformFromFunc {
+    #[inline]
+    pub fn function_sig(&self) -> Option<FunctionSig> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    pub fn from_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FROM_KW)
     }
     #[inline]
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    pub fn function_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
     }
     #[inline]
-    pub fn group_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::GROUP_KW)
+    pub fn sql_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SQL_KW)
     }
     #[inline]
-    pub fn within_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITHIN_KW)
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WithoutOids {
+pub struct TransformFuncOption {
     pub(crate) syntax: SyntaxNode,
 }
-impl WithoutOids {
-    #[inline]
-    pub fn oids_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::OIDS_KW)
-    }
+impl TransformFuncOption {
     #[inline]
-    pub fn without_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
+    pub fn transform_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRANSFORM_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WithoutTimezone {
+pub struct TransformToFunc {
     pub(crate) syntax: SyntaxNode,
 }
-impl WithoutTimezone {
+impl TransformToFunc {
     #[inline]
-    pub fn time_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::TIME_KW)
+    pub fn function_sig(&self) -> Option<FunctionSig> {
+        support::child(&self.syntax)
     }
     #[inline]
-    pub fn without_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
+    pub fn function_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
     }
     #[inline]
-    pub fn zone_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ZONE_KW)
+    pub fn sql_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SQL_KW)
     }
-}
+    #[inline]
+    pub fn to_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TO_KW)
+    }
+    #[inline]
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    }
+}
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct XmlColumnOption {
+pub struct TriggerEvent {
     pub(crate) syntax: SyntaxNode,
 }
-impl XmlColumnOption {
+impl TriggerEvent {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> {
+    pub fn trigger_event_update(&self) -> Option<TriggerEventUpdate> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn default_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    pub fn delete_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DELETE_KW)
     }
     #[inline]
-    pub fn ident_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::IDENT)
+    pub fn insert_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INSERT_KW)
     }
     #[inline]
-    pub fn not_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    pub fn truncate_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRUNCATE_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TriggerEventList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl TriggerEventList {
+    #[inline]
+    pub fn trigger_events(&self) -> AstChildren<TriggerEvent> {
+        support::children(&self.syntax)
     }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TriggerEventUpdate {
+    pub(crate) syntax: SyntaxNode,
+}
+impl TriggerEventUpdate {
     #[inline]
-    pub fn null_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    pub fn name_refs(&self) -> AstChildren<NameRef> {
+        support::children(&self.syntax)
     }
     #[inline]
-    pub fn path_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::PATH_KW)
+    pub fn of_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OF_KW)
+    }
+    #[inline]
+    pub fn update_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UPDATE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct XmlColumnOptionList {
+pub struct TrimFn {
     pub(crate) syntax: SyntaxNode,
 }
-impl XmlColumnOptionList {
+impl TrimFn {
     #[inline]
-    pub fn xml_column_option(&self) -> Option<XmlColumnOption> {
+    pub fn expr(&self) -> Option<Expr> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn xml_column_options(&self) -> AstChildren<XmlColumnOption> {
+    pub fn exprs(&self) -> AstChildren<Expr> {
         support::children(&self.syntax)
     }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn from_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FROM_KW)
+    }
+    #[inline]
+    pub fn trim_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRIM_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct XmlTableColumn {
+pub struct Truncate {
     pub(crate) syntax: SyntaxNode,
 }
-impl XmlTableColumn {
+impl Truncate {
     #[inline]
-    pub fn name(&self) -> Option<Name> {
+    pub fn table_list(&self) -> Option<TableList> {
         support::child(&self.syntax)
     }
     #[inline]
-    pub fn ty(&self) -> Option<Type> {
-        support::child(&self.syntax)
+    pub fn cascade_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CASCADE_KW)
     }
     #[inline]
-    pub fn xml_column_option_list(&self) -> Option<XmlColumnOptionList> {
-        support::child(&self.syntax)
+    pub fn continue_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONTINUE_KW)
     }
     #[inline]
-    pub fn for_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    pub fn identity_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
     }
     #[inline]
-    pub fn ordinality_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, SyntaxKind::ORDINALITY_KW)
+    pub fn restart_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTART_KW)
+    }
+    #[inline]
+    pub fn restrict_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
+    }
+    #[inline]
+    pub fn table_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLE_KW)
+    }
+    #[inline]
+    pub fn truncate_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRUNCATE_KW)
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct XmlTableColumnList {
+pub struct TupleExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl XmlTableColumnList {
+impl TupleExpr {
     #[inline]
-    pub fn xml_table_columns(&self) -> AstChildren<XmlTableColumn> {
+    pub fn exprs(&self) -> AstChildren<Expr> {
         support::children(&self.syntax)
     }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum AlterColumnOption {
-    AddGenerated(AddGenerated),
-    DropDefault(DropDefault),
-    DropExpression(DropExpression),
-    DropIdentity(DropIdentity),
-    DropNotNull(DropNotNull),
-    ResetOptions(ResetOptions),
-    Restart(Restart),
-    SetCompression(SetCompression),
-    SetDefault(SetDefault),
-    SetExpression(SetExpression),
-    SetGenerated(SetGenerated),
-    SetGeneratedOptions(SetGeneratedOptions),
-    SetNotNull(SetNotNull),
-    SetOptions(SetOptions),
-    SetOptionsList(SetOptionsList),
-    SetSequenceOption(SetSequenceOption),
-    SetStatistics(SetStatistics),
-    SetStorage(SetStorage),
-    SetType(SetType),
+pub struct UnicodeNormalForm {
+    pub(crate) syntax: SyntaxNode,
+}
+impl UnicodeNormalForm {
+    #[inline]
+    pub fn nfc_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NFC_KW)
+    }
+    #[inline]
+    pub fn nfd_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NFD_KW)
+    }
+    #[inline]
+    pub fn nfkc_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NFKC_KW)
+    }
+    #[inline]
+    pub fn nfkd_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NFKD_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum AlterDomainAction {
-    AddConstraint(AddConstraint),
-    DropConstraint(DropConstraint),
-    DropDefault(DropDefault),
-    DropNotNull(DropNotNull),
-    OwnerTo(OwnerTo),
-    RenameConstraint(RenameConstraint),
-    RenameTo(RenameTo),
-    SetDefault(SetDefault),
-    SetNotNull(SetNotNull),
-    SetSchema(SetSchema),
-    ValidateConstraint(ValidateConstraint),
+pub struct UniqueConstraint {
+    pub(crate) syntax: SyntaxNode,
+}
+impl UniqueConstraint {
+    #[inline]
+    pub fn column_list(&self) -> Option<ColumnList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn nulls_distinct(&self) -> Option<NullsDistinct> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn nulls_not_distinct(&self) -> Option<NullsNotDistinct> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn using_index(&self) -> Option<UsingIndex> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn constraint_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
+    }
+    #[inline]
+    pub fn unique_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UNIQUE_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum AlterMaterializedViewAction {
-    DependsOnExtension(DependsOnExtension),
-    NoDependsOnExtension(NoDependsOnExtension),
-    RenameColumn(RenameColumn),
-    RenameTo(RenameTo),
-    SetSchema(SetSchema),
-    AlterTableAction(AlterTableAction),
+pub struct Unlisten {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Unlisten {
+    #[inline]
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn star_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STAR)
+    }
+    #[inline]
+    pub fn unlisten_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UNLISTEN_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum AlterTableAction {
-    AddColumn(AddColumn),
-    AddConstraint(AddConstraint),
-    AlterColumn(AlterColumn),
-    AlterConstraint(AlterConstraint),
-    AttachPartition(AttachPartition),
-    ClusterOn(ClusterOn),
-    DetachPartition(DetachPartition),
-    DisableRls(DisableRls),
-    DisableRule(DisableRule),
-    DisableTrigger(DisableTrigger),
-    DropColumn(DropColumn),
-    DropConstraint(DropConstraint),
-    EnableAlwaysRule(EnableAlwaysRule),
-    EnableAlwaysTrigger(EnableAlwaysTrigger),
-    EnableReplicaRule(EnableReplicaRule),
-    EnableReplicaTrigger(EnableReplicaTrigger),
-    EnableRls(EnableRls),
-    EnableRule(EnableRule),
-    EnableTrigger(EnableTrigger),
-    ForceRls(ForceRls),
-    InheritTable(InheritTable),
-    NoForceRls(NoForceRls),
-    NoInheritTable(NoInheritTable),
-    NotOf(NotOf),
-    OfType(OfType),
-    OptionItemList(OptionItemList),
-    OwnerTo(OwnerTo),
-    RenameColumn(RenameColumn),
-    RenameConstraint(RenameConstraint),
-    RenameTo(RenameTo),
-    ReplicaIdentity(ReplicaIdentity),
-    ResetOptions(ResetOptions),
-    SetAccessMethod(SetAccessMethod),
-    SetLogged(SetLogged),
-    SetOptions(SetOptions),
-    SetSchema(SetSchema),
-    SetTablespace(SetTablespace),
-    SetUnlogged(SetUnlogged),
-    SetWithoutCluster(SetWithoutCluster),
-    SetWithoutOids(SetWithoutOids),
-    ValidateConstraint(ValidateConstraint),
+pub struct Update {
+    pub(crate) syntax: SyntaxNode,
 }
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ColumnConstraint {
-    CheckConstraint(CheckConstraint),
-    DefaultConstraint(DefaultConstraint),
-    ExcludeConstraint(ExcludeConstraint),
-    NotNullConstraint(NotNullConstraint),
-    PrimaryKeyConstraint(PrimaryKeyConstraint),
-    ReferencesConstraint(ReferencesConstraint),
-    UniqueConstraint(UniqueConstraint),
+impl Update {
+    #[inline]
+    pub fn alias(&self) -> Option<Alias> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn from_clause(&self) -> Option<FromClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn relation_name(&self) -> Option<RelationName> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn returning_clause(&self) -> Option<ReturningClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn set_clause(&self) -> Option<SetClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn where_clause(&self) -> Option<WhereClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn update_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::UPDATE_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ConflictAction {
-    ConflictDoNothing(ConflictDoNothing),
-    ConflictDoUpdateSet(ConflictDoUpdateSet),
+pub struct UsingClause {
+    pub(crate) syntax: SyntaxNode,
 }
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ConflictTarget {
-    ConflictOnConstraint(ConflictOnConstraint),
-    ConflictOnIndex(ConflictOnIndex),
+impl UsingClause {
+    #[inline]
+    pub fn from_items(&self) -> AstChildren<FromItem> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn using_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::USING_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Constraint {
-    CheckConstraint(CheckConstraint),
-    DefaultConstraint(DefaultConstraint),
-    ForeignKeyConstraint(ForeignKeyConstraint),
-    GeneratedConstraint(GeneratedConstraint),
-    NotNullConstraint(NotNullConstraint),
-    NullConstraint(NullConstraint),
-    PrimaryKeyConstraint(PrimaryKeyConstraint),
-    ReferencesConstraint(ReferencesConstraint),
-    UniqueConstraint(UniqueConstraint),
+pub struct UsingIndex {
+    pub(crate) syntax: SyntaxNode,
 }
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ExplainStmt {
-    CompoundSelect(CompoundSelect),
-    CreateMaterializedView(CreateMaterializedView),
-    CreateTableAs(CreateTableAs),
-    Declare(Declare),
-    Delete(Delete),
-    Execute(Execute),
-    Insert(Insert),
-    Merge(Merge),
-    ParenSelect(ParenSelect),
-    Select(Select),
-    SelectInto(SelectInto),
-    Table(Table),
-    Update(Update),
-    Values(Values),
+impl UsingIndex {
+    #[inline]
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn index_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INDEX_KW)
+    }
+    #[inline]
+    pub fn using_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::USING_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Expr {
-    ArrayExpr(ArrayExpr),
-    BetweenExpr(BetweenExpr),
-    BinExpr(BinExpr),
-    CallExpr(CallExpr),
-    CaseExpr(CaseExpr),
-    CastExpr(CastExpr),
-    FieldExpr(FieldExpr),
-    IndexExpr(IndexExpr),
-    Literal(Literal),
-    NameRef(NameRef),
-    ParenExpr(ParenExpr),
-    PostfixExpr(PostfixExpr),
-    PrefixExpr(PrefixExpr),
-    SliceExpr(SliceExpr),
-    TupleExpr(TupleExpr),
+pub struct UsingMethod {
+    pub(crate) syntax: SyntaxNode,
 }
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum FuncOption {
-    AsFuncOption(AsFuncOption),
-    BeginFuncOption(BeginFuncOption),
-    CostFuncOption(CostFuncOption),
-    LanguageFuncOption(LanguageFuncOption),
-    LeakproofFuncOption(LeakproofFuncOption),
-    ParallelFuncOption(ParallelFuncOption),
-    ResetFuncOption(ResetFuncOption),
-    ReturnFuncOption(ReturnFuncOption),
-    RowsFuncOption(RowsFuncOption),
-    SecurityFuncOption(SecurityFuncOption),
-    SetFuncOption(SetFuncOption),
-    StrictFuncOption(StrictFuncOption),
-    SupportFuncOption(SupportFuncOption),
-    TransformFuncOption(TransformFuncOption),
-    VolatilityFuncOption(VolatilityFuncOption),
-    WindowFuncOption(WindowFuncOption),
+impl UsingMethod {
+    #[inline]
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn using_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::USING_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum GroupBy {
-    GroupingCube(GroupingCube),
-    GroupingExpr(GroupingExpr),
-    GroupingRollup(GroupingRollup),
-    GroupingSets(GroupingSets),
+pub struct UsingOnClause {
+    pub(crate) syntax: SyntaxNode,
 }
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum JoinType {
-    JoinCross(JoinCross),
-    JoinFull(JoinFull),
-    JoinInner(JoinInner),
-    JoinLeft(JoinLeft),
-    JoinRight(JoinRight),
+impl UsingOnClause {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn from_item(&self) -> Option<FromItem> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn on_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ON_KW)
+    }
+    #[inline]
+    pub fn using_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::USING_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum JsonBehavior {
-    JsonBehaviorDefault(JsonBehaviorDefault),
-    JsonBehaviorEmptyArray(JsonBehaviorEmptyArray),
-    JsonBehaviorEmptyObject(JsonBehaviorEmptyObject),
-    JsonBehaviorError(JsonBehaviorError),
-    JsonBehaviorFalse(JsonBehaviorFalse),
-    JsonBehaviorNull(JsonBehaviorNull),
-    JsonBehaviorTrue(JsonBehaviorTrue),
-    JsonBehaviorUnknown(JsonBehaviorUnknown),
+pub struct Vacuum {
+    pub(crate) syntax: SyntaxNode,
 }
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum MatchType {
-    MatchFull(MatchFull),
-    MatchPartial(MatchPartial),
-    MatchSimple(MatchSimple),
+impl Vacuum {
+    #[inline]
+    pub fn relation_name(&self) -> Option<RelationName> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn vacuum_option_list(&self) -> Option<VacuumOptionList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn vacuum_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VACUUM_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum MergeAction {
-    MergeDelete(MergeDelete),
-    MergeDoNothing(MergeDoNothing),
-    MergeInsert(MergeInsert),
-    MergeUpdate(MergeUpdate),
+pub struct VacuumOption {
+    pub(crate) syntax: SyntaxNode,
 }
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum MergeWhenClause {
-    MergeWhenMatched(MergeWhenMatched),
-    MergeWhenNotMatchedSource(MergeWhenNotMatchedSource),
-    MergeWhenNotMatchedTarget(MergeWhenNotMatchedTarget),
+impl VacuumOption {
+    #[inline]
+    pub fn full_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FULL_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum OnCommitAction {
-    DeleteRows(DeleteRows),
-    Drop(Drop),
-    PreserveRows(PreserveRows),
+pub struct VacuumOptionList {
+    pub(crate) syntax: SyntaxNode,
 }
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ParamMode {
-    ParamIn(ParamIn),
-    ParamInOut(ParamInOut),
-    ParamOut(ParamOut),
-    ParamVariadic(ParamVariadic),
+impl VacuumOptionList {
+    #[inline]
+    pub fn vacuum_options(&self) -> AstChildren<VacuumOption> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum PartitionType {
-    PartitionDefault(PartitionDefault),
-    PartitionForValuesFrom(PartitionForValuesFrom),
-    PartitionForValuesIn(PartitionForValuesIn),
-    PartitionForValuesWith(PartitionForValuesWith),
+pub struct ValidateConstraint {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ValidateConstraint {
+    #[inline]
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn constraint_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
+    }
+    #[inline]
+    pub fn validate_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VALIDATE_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum PreparableStmt {
-    CompoundSelect(CompoundSelect),
-    Delete(Delete),
-    Insert(Insert),
-    Merge(Merge),
-    Select(Select),
-    SelectInto(SelectInto),
-    Table(Table),
-    Update(Update),
-    Values(Values),
+pub struct Values {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Values {
+    #[inline]
+    pub fn row_list(&self) -> Option<RowList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn values_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VALUES_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum RefAction {
-    Cascade(Cascade),
-    NoAction(NoAction),
-    Restrict(Restrict),
-    SetDefaultColumns(SetDefaultColumns),
-    SetNullColumns(SetNullColumns),
+pub struct Variant {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Variant {
+    #[inline]
+    pub fn literal(&self) -> Option<Literal> {
+        support::child(&self.syntax)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum SchemaElement {
-    CreateIndex(CreateIndex),
-    CreateSequence(CreateSequence),
-    CreateTable(CreateTable),
-    CreateTrigger(CreateTrigger),
-    CreateView(CreateView),
-    Grant(Grant),
+pub struct VariantList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl VariantList {
+    #[inline]
+    pub fn variants(&self) -> AstChildren<Variant> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum SelectVariant {
-    CompoundSelect(CompoundSelect),
-    ParenSelect(ParenSelect),
-    Select(Select),
-    SelectInto(SelectInto),
-    Table(Table),
-    Values(Values),
+pub struct VolatilityFuncOption {
+    pub(crate) syntax: SyntaxNode,
+}
+impl VolatilityFuncOption {
+    #[inline]
+    pub fn immutable_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IMMUTABLE_KW)
+    }
+    #[inline]
+    pub fn stable_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STABLE_KW)
+    }
+    #[inline]
+    pub fn volatile_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VOLATILE_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum SetColumn {
-    SetMultipleColumns(SetMultipleColumns),
-    SetSingleColumn(SetSingleColumn),
+pub struct WhenClause {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WhenClause {
+    #[inline]
+    pub fn then_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::THEN_KW)
+    }
+    #[inline]
+    pub fn when_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WHEN_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Stmt {
-    AlterAggregate(AlterAggregate),
-    AlterCollation(AlterCollation),
-    AlterConversion(AlterConversion),
-    AlterDatabase(AlterDatabase),
-    AlterDefaultPrivileges(AlterDefaultPrivileges),
-    AlterDomain(AlterDomain),
-    AlterEventTrigger(AlterEventTrigger),
-    AlterExtension(AlterExtension),
-    AlterForeignDataWrapper(AlterForeignDataWrapper),
-    AlterForeignTable(AlterForeignTable),
-    AlterFunction(AlterFunction),
-    AlterGroup(AlterGroup),
-    AlterIndex(AlterIndex),
-    AlterLanguage(AlterLanguage),
-    AlterLargeObject(AlterLargeObject),
-    AlterMaterializedView(AlterMaterializedView),
-    AlterOperator(AlterOperator),
-    AlterOperatorClass(AlterOperatorClass),
-    AlterOperatorFamily(AlterOperatorFamily),
-    AlterPolicy(AlterPolicy),
-    AlterProcedure(AlterProcedure),
-    AlterPublication(AlterPublication),
-    AlterRole(AlterRole),
-    AlterRoutine(AlterRoutine),
-    AlterRule(AlterRule),
-    AlterSchema(AlterSchema),
-    AlterSequence(AlterSequence),
-    AlterServer(AlterServer),
-    AlterStatistics(AlterStatistics),
-    AlterSubscription(AlterSubscription),
-    AlterSystem(AlterSystem),
-    AlterTable(AlterTable),
-    AlterTablespace(AlterTablespace),
-    AlterTextSearchConfiguration(AlterTextSearchConfiguration),
-    AlterTextSearchDictionary(AlterTextSearchDictionary),
-    AlterTextSearchParser(AlterTextSearchParser),
-    AlterTextSearchTemplate(AlterTextSearchTemplate),
-    AlterTrigger(AlterTrigger),
-    AlterType(AlterType),
-    AlterUser(AlterUser),
-    AlterUserMapping(AlterUserMapping),
-    AlterView(AlterView),
-    Analyze(Analyze),
-    Begin(Begin),
-    Call(Call),
-    Checkpoint(Checkpoint),
-    Close(Close),
-    Cluster(Cluster),
-    CommentOn(CommentOn),
-    Commit(Commit),
-    Copy(Copy),
-    CreateAccessMethod(CreateAccessMethod),
-    CreateAggregate(CreateAggregate),
-    CreateCast(CreateCast),
-    CreateCollation(CreateCollation),
-    CreateConversion(CreateConversion),
-    CreateDatabase(CreateDatabase),
-    CreateDomain(CreateDomain),
-    CreateEventTrigger(CreateEventTrigger),
-    CreateExtension(CreateExtension),
-    CreateForeignDataWrapper(CreateForeignDataWrapper),
-    CreateForeignTable(CreateForeignTable),
-    CreateFunction(CreateFunction),
-    CreateGroup(CreateGroup),
-    CreateIndex(CreateIndex),
-    CreateLanguage(CreateLanguage),
-    CreateMaterializedView(CreateMaterializedView),
-    CreateOperator(CreateOperator),
-    CreateOperatorClass(CreateOperatorClass),
-    CreateOperatorFamily(CreateOperatorFamily),
-    CreatePolicy(CreatePolicy),
-    CreateProcedure(CreateProcedure),
-    CreatePublication(CreatePublication),
-    CreateRole(CreateRole),
-    CreateRule(CreateRule),
-    CreateSchema(CreateSchema),
-    CreateSequence(CreateSequence),
-    CreateServer(CreateServer),
-    CreateStatistics(CreateStatistics),
-    CreateSubscription(CreateSubscription),
-    CreateTable(CreateTable),
-    CreateTableAs(CreateTableAs),
-    CreateTablespace(CreateTablespace),
-    CreateTextSearchConfiguration(CreateTextSearchConfiguration),
-    CreateTextSearchDictionary(CreateTextSearchDictionary),
-    CreateTextSearchParser(CreateTextSearchParser),
-    CreateTextSearchTemplate(CreateTextSearchTemplate),
-    CreateTransform(CreateTransform),
-    CreateTrigger(CreateTrigger),
-    CreateType(CreateType),
-    CreateUser(CreateUser),
-    CreateUserMapping(CreateUserMapping),
-    CreateView(CreateView),
-    Deallocate(Deallocate),
-    Declare(Declare),
-    Delete(Delete),
-    Discard(Discard),
-    Do(Do),
-    DropAccessMethod(DropAccessMethod),
-    DropAggregate(DropAggregate),
-    DropCast(DropCast),
-    DropCollation(DropCollation),
-    DropConversion(DropConversion),
-    DropDatabase(DropDatabase),
-    DropDomain(DropDomain),
-    DropEventTrigger(DropEventTrigger),
-    DropExtension(DropExtension),
-    DropForeignDataWrapper(DropForeignDataWrapper),
-    DropForeignTable(DropForeignTable),
-    DropFunction(DropFunction),
-    DropGroup(DropGroup),
-    DropIndex(DropIndex),
-    DropLanguage(DropLanguage),
-    DropMaterializedView(DropMaterializedView),
-    DropOperator(DropOperator),
-    DropOperatorClass(DropOperatorClass),
-    DropOperatorFamily(DropOperatorFamily),
-    DropOwned(DropOwned),
-    DropPolicy(DropPolicy),
-    DropProcedure(DropProcedure),
-    DropPublication(DropPublication),
-    DropRole(DropRole),
-    DropRoutine(DropRoutine),
-    DropRule(DropRule),
-    DropSchema(DropSchema),
-    DropSequence(DropSequence),
-    DropServer(DropServer),
-    DropStatistics(DropStatistics),
-    DropSubscription(DropSubscription),
-    DropTable(DropTable),
-    DropTablespace(DropTablespace),
-    DropTextSearchConfig(DropTextSearchConfig),
-    DropTextSearchDict(DropTextSearchDict),
-    DropTextSearchParser(DropTextSearchParser),
-    DropTextSearchTemplate(DropTextSearchTemplate),
-    DropTransform(DropTransform),
-    DropTrigger(DropTrigger),
-    DropType(DropType),
-    DropUser(DropUser),
-    DropUserMapping(DropUserMapping),
-    DropView(DropView),
-    Execute(Execute),
-    Explain(Explain),
-    Fetch(Fetch),
-    Grant(Grant),
-    ImportForeignSchema(ImportForeignSchema),
-    Insert(Insert),
-    Listen(Listen),
-    Load(Load),
-    Lock(Lock),
-    Merge(Merge),
-    Move(Move),
-    Notify(Notify),
-    ParenSelect(ParenSelect),
-    Prepare(Prepare),
-    PrepareTransaction(PrepareTransaction),
-    Reassign(Reassign),
-    Refresh(Refresh),
-    Reindex(Reindex),
-    ReleaseSavepoint(ReleaseSavepoint),
-    Reset(Reset),
-    ResetSessionAuth(ResetSessionAuth),
-    Revoke(Revoke),
-    Rollback(Rollback),
-    Savepoint(Savepoint),
-    SecurityLabel(SecurityLabel),
-    Select(Select),
-    SelectInto(SelectInto),
-    Set(Set),
-    SetConstraints(SetConstraints),
-    SetRole(SetRole),
-    SetSessionAuth(SetSessionAuth),
-    SetTransaction(SetTransaction),
-    Show(Show),
-    Table(Table),
-    Truncate(Truncate),
-    Unlisten(Unlisten),
-    Update(Update),
-    Vacuum(Vacuum),
-    Values(Values),
+pub struct WhenClauseList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WhenClauseList {
+    #[inline]
+    pub fn when_clause(&self) -> Option<WhenClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn when_clauses(&self) -> AstChildren<WhenClause> {
+        support::children(&self.syntax)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum TableArg {
-    Column(Column),
-    LikeClause(LikeClause),
-    TableConstraint(TableConstraint),
+pub struct WhenCondition {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WhenCondition {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn when_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WHEN_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum TableConstraint {
-    CheckConstraint(CheckConstraint),
-    ExcludeConstraint(ExcludeConstraint),
-    ForeignKeyConstraint(ForeignKeyConstraint),
-    PrimaryKeyConstraint(PrimaryKeyConstraint),
-    UniqueConstraint(UniqueConstraint),
+pub struct WhereClause {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WhereClause {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn where_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WHERE_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Timezone {
-    WithTimezone(WithTimezone),
-    WithoutTimezone(WithoutTimezone),
+pub struct WhereConditionClause {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WhereConditionClause {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn where_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WHERE_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum TransactionMode {
-    Deferrable(Deferrable),
-    NotDeferrable(NotDeferrable),
-    ReadCommitted(ReadCommitted),
-    ReadOnly(ReadOnly),
-    ReadUncommitted(ReadUncommitted),
-    ReadWrite(ReadWrite),
-    RepeatableRead(RepeatableRead),
-    Serializable(Serializable),
+pub struct WhereCurrentOf {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WhereCurrentOf {
+    #[inline]
+    pub fn name_ref(&self) -> Option<NameRef> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn current_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CURRENT_KW)
+    }
+    #[inline]
+    pub fn of_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OF_KW)
+    }
+    #[inline]
+    pub fn where_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WHERE_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WindowClause {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WindowClause {
+    #[inline]
+    pub fn window_defs(&self) -> AstChildren<WindowDef> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn window_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WINDOW_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WindowDef {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WindowDef {
+    #[inline]
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn window_spec(&self) -> Option<WindowSpec> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WindowFuncOption {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WindowFuncOption {
+    #[inline]
+    pub fn window_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WINDOW_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WindowSpec {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WindowSpec {
+    #[inline]
+    pub fn exprs(&self) -> AstChildren<Expr> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn frame_clause(&self) -> Option<FrameClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn order_by_clause(&self) -> Option<OrderByClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn by_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::BY_KW)
+    }
+    #[inline]
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
+    }
+    #[inline]
+    pub fn partition_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PARTITION_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WithClause {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WithClause {
+    #[inline]
+    pub fn with_tables(&self) -> AstChildren<WithTable> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn recursive_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RECURSIVE_KW)
+    }
+    #[inline]
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WithData {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WithData {
+    #[inline]
+    pub fn data_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DATA_KW)
+    }
+    #[inline]
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WithNoData {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WithNoData {
+    #[inline]
+    pub fn data_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DATA_KW)
+    }
+    #[inline]
+    pub fn no_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NO_KW)
+    }
+    #[inline]
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WithOptions {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WithOptions {
+    #[inline]
+    pub fn options_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OPTIONS_KW)
+    }
+    #[inline]
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WithParams {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WithParams {
+    #[inline]
+    pub fn attribute_list(&self) -> Option<AttributeList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WithTable {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WithTable {
+    #[inline]
+    pub fn column_list(&self) -> Option<ColumnList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn materialized(&self) -> Option<Materialized> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn not_materialized(&self) -> Option<NotMaterialized> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn query(&self) -> Option<WithQuery> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WithTimezone {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WithTimezone {
+    #[inline]
+    pub fn time_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TIME_KW)
+    }
+    #[inline]
+    pub fn with_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITH_KW)
+    }
+    #[inline]
+    pub fn zone_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ZONE_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WithinClause {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WithinClause {
+    #[inline]
+    pub fn order_by_clause(&self) -> Option<OrderByClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn group_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::GROUP_KW)
+    }
+    #[inline]
+    pub fn within_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITHIN_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WithoutOids {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WithoutOids {
+    #[inline]
+    pub fn oids_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OIDS_KW)
+    }
+    #[inline]
+    pub fn without_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WithoutTimezone {
+    pub(crate) syntax: SyntaxNode,
+}
+impl WithoutTimezone {
+    #[inline]
+    pub fn time_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TIME_KW)
+    }
+    #[inline]
+    pub fn without_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
+    }
+    #[inline]
+    pub fn zone_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ZONE_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlAttributeList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlAttributeList {
+    #[inline]
+    pub fn expr_as_names(&self) -> AstChildren<ExprAsName> {
+        support::children(&self.syntax)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlColumnOption {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlColumnOption {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    }
+    #[inline]
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
+    }
+    #[inline]
+    pub fn not_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NOT_KW)
+    }
+    #[inline]
+    pub fn null_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NULL_KW)
+    }
+    #[inline]
+    pub fn path_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PATH_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlColumnOptionList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlColumnOptionList {
+    #[inline]
+    pub fn xml_column_option(&self) -> Option<XmlColumnOption> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_column_options(&self) -> AstChildren<XmlColumnOption> {
+        support::children(&self.syntax)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlElementFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlElementFn {
+    #[inline]
+    pub fn exprs(&self) -> AstChildren<Expr> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_attribute_list(&self) -> Option<XmlAttributeList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn comma_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMA)
+    }
+    #[inline]
+    pub fn name_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NAME_KW)
+    }
+    #[inline]
+    pub fn xmlattributes_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::XMLATTRIBUTES_KW)
+    }
+    #[inline]
+    pub fn xmlelement_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::XMLELEMENT_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlExistsFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlExistsFn {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_passing_mech(&self) -> Option<XmlPassingMech> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn passing_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PASSING_KW)
+    }
+    #[inline]
+    pub fn xmlexists_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::XMLEXISTS_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlForestFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlForestFn {
+    #[inline]
+    pub fn xml_attribute_list(&self) -> Option<XmlAttributeList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn xmlforest_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::XMLFOREST_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlNamespace {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlNamespace {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
+    }
+    #[inline]
+    pub fn default_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlNamespaceList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlNamespaceList {
+    #[inline]
+    pub fn xml_namespaces(&self) -> AstChildren<XmlNamespace> {
+        support::children(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlParseFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlParseFn {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn content_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONTENT_KW)
+    }
+    #[inline]
+    pub fn document_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DOCUMENT_KW)
+    }
+    #[inline]
+    pub fn preserve_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PRESERVE_KW)
+    }
+    #[inline]
+    pub fn strip_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STRIP_KW)
+    }
+    #[inline]
+    pub fn whitespace_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WHITESPACE_KW)
+    }
+    #[inline]
+    pub fn xmlparse_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::XMLPARSE_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlPassingMech {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlPassingMech {
+    #[inline]
+    pub fn by_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::BY_KW)
+    }
+    #[inline]
+    pub fn ref_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::REF_KW)
+    }
+    #[inline]
+    pub fn value_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VALUE_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlPiFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlPiFn {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn comma_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMA)
+    }
+    #[inline]
+    pub fn name_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NAME_KW)
+    }
+    #[inline]
+    pub fn xmlpi_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::XMLPI_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlRootFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlRootFn {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn comma_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMA)
+    }
+    #[inline]
+    pub fn no_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NO_KW)
+    }
+    #[inline]
+    pub fn standalone_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STANDALONE_KW)
+    }
+    #[inline]
+    pub fn value_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VALUE_KW)
+    }
+    #[inline]
+    pub fn version_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VERSION_KW)
+    }
+    #[inline]
+    pub fn xmlroot_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::XMLROOT_KW)
+    }
+    #[inline]
+    pub fn yes_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::YES_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlRowPassingClause {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlRowPassingClause {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_passing_mech(&self) -> Option<XmlPassingMech> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn passing_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PASSING_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlSerializeFn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlSerializeFn {
+    #[inline]
+    pub fn expr(&self) -> Option<Expr> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn ty(&self) -> Option<Type> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn as_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AS_KW)
+    }
+    #[inline]
+    pub fn content_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONTENT_KW)
+    }
+    #[inline]
+    pub fn document_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DOCUMENT_KW)
+    }
+    #[inline]
+    pub fn ident_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::IDENT)
+    }
+    #[inline]
+    pub fn no_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::NO_KW)
+    }
+    #[inline]
+    pub fn xmlserialize_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::XMLSERIALIZE_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlTable {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlTable {
+    #[inline]
+    pub fn xml_namespace_list(&self) -> Option<XmlNamespaceList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_row_passing_clause(&self) -> Option<XmlRowPassingClause> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_table_column_list(&self) -> Option<XmlTableColumnList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn comma_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMA)
+    }
+    #[inline]
+    pub fn xmlnamespaces_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::XMLNAMESPACES_KW)
+    }
+    #[inline]
+    pub fn xmltable_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::XMLTABLE_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlTableColumn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlTableColumn {
+    #[inline]
+    pub fn name(&self) -> Option<Name> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn ty(&self) -> Option<Type> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn xml_column_option_list(&self) -> Option<XmlColumnOptionList> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    }
+    #[inline]
+    pub fn ordinality_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ORDINALITY_KW)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct XmlTableColumnList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl XmlTableColumnList {
+    #[inline]
+    pub fn xml_table_columns(&self) -> AstChildren<XmlTableColumn> {
+        support::children(&self.syntax)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum AlterColumnOption {
+    AddGenerated(AddGenerated),
+    DropDefault(DropDefault),
+    DropExpression(DropExpression),
+    DropIdentity(DropIdentity),
+    DropNotNull(DropNotNull),
+    ResetOptions(ResetOptions),
+    Restart(Restart),
+    SetCompression(SetCompression),
+    SetDefault(SetDefault),
+    SetExpression(SetExpression),
+    SetGenerated(SetGenerated),
+    SetGeneratedOptions(SetGeneratedOptions),
+    SetNotNull(SetNotNull),
+    SetOptions(SetOptions),
+    SetOptionsList(SetOptionsList),
+    SetSequenceOption(SetSequenceOption),
+    SetStatistics(SetStatistics),
+    SetStorage(SetStorage),
+    SetType(SetType),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum AlterDomainAction {
+    AddConstraint(AddConstraint),
+    DropConstraint(DropConstraint),
+    DropDefault(DropDefault),
+    DropNotNull(DropNotNull),
+    OwnerTo(OwnerTo),
+    RenameConstraint(RenameConstraint),
+    RenameTo(RenameTo),
+    SetDefault(SetDefault),
+    SetNotNull(SetNotNull),
+    SetSchema(SetSchema),
+    ValidateConstraint(ValidateConstraint),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum AlterMaterializedViewAction {
+    DependsOnExtension(DependsOnExtension),
+    NoDependsOnExtension(NoDependsOnExtension),
+    RenameColumn(RenameColumn),
+    RenameTo(RenameTo),
+    SetSchema(SetSchema),
+    AlterTableAction(AlterTableAction),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum AlterTableAction {
+    AddColumn(AddColumn),
+    AddConstraint(AddConstraint),
+    AlterColumn(AlterColumn),
+    AlterConstraint(AlterConstraint),
+    AttachPartition(AttachPartition),
+    ClusterOn(ClusterOn),
+    DetachPartition(DetachPartition),
+    DisableRls(DisableRls),
+    DisableRule(DisableRule),
+    DisableTrigger(DisableTrigger),
+    DropColumn(DropColumn),
+    DropConstraint(DropConstraint),
+    EnableAlwaysRule(EnableAlwaysRule),
+    EnableAlwaysTrigger(EnableAlwaysTrigger),
+    EnableReplicaRule(EnableReplicaRule),
+    EnableReplicaTrigger(EnableReplicaTrigger),
+    EnableRls(EnableRls),
+    EnableRule(EnableRule),
+    EnableTrigger(EnableTrigger),
+    ForceRls(ForceRls),
+    InheritTable(InheritTable),
+    NoForceRls(NoForceRls),
+    NoInheritTable(NoInheritTable),
+    NotOf(NotOf),
+    OfType(OfType),
+    OptionItemList(OptionItemList),
+    OwnerTo(OwnerTo),
+    RenameColumn(RenameColumn),
+    RenameConstraint(RenameConstraint),
+    RenameTo(RenameTo),
+    ReplicaIdentity(ReplicaIdentity),
+    ResetOptions(ResetOptions),
+    SetAccessMethod(SetAccessMethod),
+    SetLogged(SetLogged),
+    SetOptions(SetOptions),
+    SetSchema(SetSchema),
+    SetTablespace(SetTablespace),
+    SetUnlogged(SetUnlogged),
+    SetWithoutCluster(SetWithoutCluster),
+    SetWithoutOids(SetWithoutOids),
+    ValidateConstraint(ValidateConstraint),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ColumnConstraint {
+    CheckConstraint(CheckConstraint),
+    DefaultConstraint(DefaultConstraint),
+    ExcludeConstraint(ExcludeConstraint),
+    NotNullConstraint(NotNullConstraint),
+    PrimaryKeyConstraint(PrimaryKeyConstraint),
+    ReferencesConstraint(ReferencesConstraint),
+    UniqueConstraint(UniqueConstraint),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ConflictAction {
+    ConflictDoNothing(ConflictDoNothing),
+    ConflictDoUpdateSet(ConflictDoUpdateSet),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ConflictTarget {
+    ConflictOnConstraint(ConflictOnConstraint),
+    ConflictOnIndex(ConflictOnIndex),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Constraint {
+    CheckConstraint(CheckConstraint),
+    DefaultConstraint(DefaultConstraint),
+    ForeignKeyConstraint(ForeignKeyConstraint),
+    GeneratedConstraint(GeneratedConstraint),
+    NotNullConstraint(NotNullConstraint),
+    NullConstraint(NullConstraint),
+    PrimaryKeyConstraint(PrimaryKeyConstraint),
+    ReferencesConstraint(ReferencesConstraint),
+    UniqueConstraint(UniqueConstraint),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ExplainStmt {
+    CompoundSelect(CompoundSelect),
+    CreateMaterializedView(CreateMaterializedView),
+    CreateTableAs(CreateTableAs),
+    Declare(Declare),
+    Delete(Delete),
+    Execute(Execute),
+    Insert(Insert),
+    Merge(Merge),
+    ParenSelect(ParenSelect),
+    Select(Select),
+    SelectInto(SelectInto),
+    Table(Table),
+    Update(Update),
+    Values(Values),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Expr {
+    ArrayExpr(ArrayExpr),
+    BetweenExpr(BetweenExpr),
+    BinExpr(BinExpr),
+    CallExpr(CallExpr),
+    CaseExpr(CaseExpr),
+    CastExpr(CastExpr),
+    FieldExpr(FieldExpr),
+    IndexExpr(IndexExpr),
+    Literal(Literal),
+    NameRef(NameRef),
+    ParenExpr(ParenExpr),
+    PostfixExpr(PostfixExpr),
+    PrefixExpr(PrefixExpr),
+    SliceExpr(SliceExpr),
+    TupleExpr(TupleExpr),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum FuncOption {
+    AsFuncOption(AsFuncOption),
+    BeginFuncOption(BeginFuncOption),
+    CostFuncOption(CostFuncOption),
+    LanguageFuncOption(LanguageFuncOption),
+    LeakproofFuncOption(LeakproofFuncOption),
+    ParallelFuncOption(ParallelFuncOption),
+    ResetFuncOption(ResetFuncOption),
+    ReturnFuncOption(ReturnFuncOption),
+    RowsFuncOption(RowsFuncOption),
+    SecurityFuncOption(SecurityFuncOption),
+    SetFuncOption(SetFuncOption),
+    StrictFuncOption(StrictFuncOption),
+    SupportFuncOption(SupportFuncOption),
+    TransformFuncOption(TransformFuncOption),
+    VolatilityFuncOption(VolatilityFuncOption),
+    WindowFuncOption(WindowFuncOption),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum GroupBy {
+    GroupingCube(GroupingCube),
+    GroupingExpr(GroupingExpr),
+    GroupingRollup(GroupingRollup),
+    GroupingSets(GroupingSets),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum JoinType {
+    JoinCross(JoinCross),
+    JoinFull(JoinFull),
+    JoinInner(JoinInner),
+    JoinLeft(JoinLeft),
+    JoinRight(JoinRight),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum JsonBehavior {
+    JsonBehaviorDefault(JsonBehaviorDefault),
+    JsonBehaviorEmptyArray(JsonBehaviorEmptyArray),
+    JsonBehaviorEmptyObject(JsonBehaviorEmptyObject),
+    JsonBehaviorError(JsonBehaviorError),
+    JsonBehaviorFalse(JsonBehaviorFalse),
+    JsonBehaviorNull(JsonBehaviorNull),
+    JsonBehaviorTrue(JsonBehaviorTrue),
+    JsonBehaviorUnknown(JsonBehaviorUnknown),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum MatchType {
+    MatchFull(MatchFull),
+    MatchPartial(MatchPartial),
+    MatchSimple(MatchSimple),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum MergeAction {
+    MergeDelete(MergeDelete),
+    MergeDoNothing(MergeDoNothing),
+    MergeInsert(MergeInsert),
+    MergeUpdate(MergeUpdate),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum MergeWhenClause {
+    MergeWhenMatched(MergeWhenMatched),
+    MergeWhenNotMatchedSource(MergeWhenNotMatchedSource),
+    MergeWhenNotMatchedTarget(MergeWhenNotMatchedTarget),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum OnCommitAction {
+    DeleteRows(DeleteRows),
+    Drop(Drop),
+    PreserveRows(PreserveRows),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ParamMode {
+    ParamIn(ParamIn),
+    ParamInOut(ParamInOut),
+    ParamOut(ParamOut),
+    ParamVariadic(ParamVariadic),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum PartitionType {
+    PartitionDefault(PartitionDefault),
+    PartitionForValuesFrom(PartitionForValuesFrom),
+    PartitionForValuesIn(PartitionForValuesIn),
+    PartitionForValuesWith(PartitionForValuesWith),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum PreparableStmt {
+    CompoundSelect(CompoundSelect),
+    Delete(Delete),
+    Insert(Insert),
+    Merge(Merge),
+    Select(Select),
+    SelectInto(SelectInto),
+    Table(Table),
+    Update(Update),
+    Values(Values),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum RefAction {
+    Cascade(Cascade),
+    NoAction(NoAction),
+    Restrict(Restrict),
+    SetDefaultColumns(SetDefaultColumns),
+    SetNullColumns(SetNullColumns),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum SchemaElement {
+    CreateIndex(CreateIndex),
+    CreateSequence(CreateSequence),
+    CreateTable(CreateTable),
+    CreateTrigger(CreateTrigger),
+    CreateView(CreateView),
+    Grant(Grant),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum SelectVariant {
+    CompoundSelect(CompoundSelect),
+    ParenSelect(ParenSelect),
+    Select(Select),
+    SelectInto(SelectInto),
+    Table(Table),
+    Values(Values),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum SetColumn {
+    SetMultipleColumns(SetMultipleColumns),
+    SetSingleColumn(SetSingleColumn),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Stmt {
+    AlterAggregate(AlterAggregate),
+    AlterCollation(AlterCollation),
+    AlterConversion(AlterConversion),
+    AlterDatabase(AlterDatabase),
+    AlterDefaultPrivileges(AlterDefaultPrivileges),
+    AlterDomain(AlterDomain),
+    AlterEventTrigger(AlterEventTrigger),
+    AlterExtension(AlterExtension),
+    AlterForeignDataWrapper(AlterForeignDataWrapper),
+    AlterForeignTable(AlterForeignTable),
+    AlterFunction(AlterFunction),
+    AlterGroup(AlterGroup),
+    AlterIndex(AlterIndex),
+    AlterLanguage(AlterLanguage),
+    AlterLargeObject(AlterLargeObject),
+    AlterMaterializedView(AlterMaterializedView),
+    AlterOperator(AlterOperator),
+    AlterOperatorClass(AlterOperatorClass),
+    AlterOperatorFamily(AlterOperatorFamily),
+    AlterPolicy(AlterPolicy),
+    AlterProcedure(AlterProcedure),
+    AlterPublication(AlterPublication),
+    AlterRole(AlterRole),
+    AlterRoutine(AlterRoutine),
+    AlterRule(AlterRule),
+    AlterSchema(AlterSchema),
+    AlterSequence(AlterSequence),
+    AlterServer(AlterServer),
+    AlterStatistics(AlterStatistics),
+    AlterSubscription(AlterSubscription),
+    AlterSystem(AlterSystem),
+    AlterTable(AlterTable),
+    AlterTablespace(AlterTablespace),
+    AlterTextSearchConfiguration(AlterTextSearchConfiguration),
+    AlterTextSearchDictionary(AlterTextSearchDictionary),
+    AlterTextSearchParser(AlterTextSearchParser),
+    AlterTextSearchTemplate(AlterTextSearchTemplate),
+    AlterTrigger(AlterTrigger),
+    AlterType(AlterType),
+    AlterUser(AlterUser),
+    AlterUserMapping(AlterUserMapping),
+    AlterView(AlterView),
+    Analyze(Analyze),
+    Begin(Begin),
+    Call(Call),
+    Checkpoint(Checkpoint),
+    Close(Close),
+    Cluster(Cluster),
+    CommentOn(CommentOn),
+    Commit(Commit),
+    Copy(Copy),
+    CreateAccessMethod(CreateAccessMethod),
+    CreateAggregate(CreateAggregate),
+    CreateCast(CreateCast),
+    CreateCollation(CreateCollation),
+    CreateConversion(CreateConversion),
+    CreateDatabase(CreateDatabase),
+    CreateDomain(CreateDomain),
+    CreateEventTrigger(CreateEventTrigger),
+    CreateExtension(CreateExtension),
+    CreateForeignDataWrapper(CreateForeignDataWrapper),
+    CreateForeignTable(CreateForeignTable),
+    CreateFunction(CreateFunction),
+    CreateGroup(CreateGroup),
+    CreateIndex(CreateIndex),
+    CreateLanguage(CreateLanguage),
+    CreateMaterializedView(CreateMaterializedView),
+    CreateOperator(CreateOperator),
+    CreateOperatorClass(CreateOperatorClass),
+    CreateOperatorFamily(CreateOperatorFamily),
+    CreatePolicy(CreatePolicy),
+    CreateProcedure(CreateProcedure),
+    CreatePublication(CreatePublication),
+    CreateRole(CreateRole),
+    CreateRule(CreateRule),
+    CreateSchema(CreateSchema),
+    CreateSequence(CreateSequence),
+    CreateServer(CreateServer),
+    CreateStatistics(CreateStatistics),
+    CreateSubscription(CreateSubscription),
+    CreateTable(CreateTable),
+    CreateTableAs(CreateTableAs),
+    CreateTablespace(CreateTablespace),
+    CreateTextSearchConfiguration(CreateTextSearchConfiguration),
+    CreateTextSearchDictionary(CreateTextSearchDictionary),
+    CreateTextSearchParser(CreateTextSearchParser),
+    CreateTextSearchTemplate(CreateTextSearchTemplate),
+    CreateTransform(CreateTransform),
+    CreateTrigger(CreateTrigger),
+    CreateType(CreateType),
+    CreateUser(CreateUser),
+    CreateUserMapping(CreateUserMapping),
+    CreateView(CreateView),
+    Deallocate(Deallocate),
+    Declare(Declare),
+    Delete(Delete),
+    Discard(Discard),
+    Do(Do),
+    DropAccessMethod(DropAccessMethod),
+    DropAggregate(DropAggregate),
+    DropCast(DropCast),
+    DropCollation(DropCollation),
+    DropConversion(DropConversion),
+    DropDatabase(DropDatabase),
+    DropDomain(DropDomain),
+    DropEventTrigger(DropEventTrigger),
+    DropExtension(DropExtension),
+    DropForeignDataWrapper(DropForeignDataWrapper),
+    DropForeignTable(DropForeignTable),
+    DropFunction(DropFunction),
+    DropGroup(DropGroup),
+    DropIndex(DropIndex),
+    DropLanguage(DropLanguage),
+    DropMaterializedView(DropMaterializedView),
+    DropOperator(DropOperator),
+    DropOperatorClass(DropOperatorClass),
+    DropOperatorFamily(DropOperatorFamily),
+    DropOwned(DropOwned),
+    DropPolicy(DropPolicy),
+    DropProcedure(DropProcedure),
+    DropPublication(DropPublication),
+    DropRole(DropRole),
+    DropRoutine(DropRoutine),
+    DropRule(DropRule),
+    DropSchema(DropSchema),
+    DropSequence(DropSequence),
+    DropServer(DropServer),
+    DropStatistics(DropStatistics),
+    DropSubscription(DropSubscription),
+    DropTable(DropTable),
+    DropTablespace(DropTablespace),
+    DropTextSearchConfig(DropTextSearchConfig),
+    DropTextSearchDict(DropTextSearchDict),
+    DropTextSearchParser(DropTextSearchParser),
+    DropTextSearchTemplate(DropTextSearchTemplate),
+    DropTransform(DropTransform),
+    DropTrigger(DropTrigger),
+    DropType(DropType),
+    DropUser(DropUser),
+    DropUserMapping(DropUserMapping),
+    DropView(DropView),
+    Execute(Execute),
+    Explain(Explain),
+    Fetch(Fetch),
+    Grant(Grant),
+    ImportForeignSchema(ImportForeignSchema),
+    Insert(Insert),
+    Listen(Listen),
+    Load(Load),
+    Lock(Lock),
+    Merge(Merge),
+    Move(Move),
+    Notify(Notify),
+    ParenSelect(ParenSelect),
+    Prepare(Prepare),
+    PrepareTransaction(PrepareTransaction),
+    Reassign(Reassign),
+    Refresh(Refresh),
+    Reindex(Reindex),
+    ReleaseSavepoint(ReleaseSavepoint),
+    Reset(Reset),
+    ResetSessionAuth(ResetSessionAuth),
+    Revoke(Revoke),
+    Rollback(Rollback),
+    Savepoint(Savepoint),
+    SecurityLabel(SecurityLabel),
+    Select(Select),
+    SelectInto(SelectInto),
+    Set(Set),
+    SetConstraints(SetConstraints),
+    SetRole(SetRole),
+    SetSessionAuth(SetSessionAuth),
+    SetTransaction(SetTransaction),
+    Show(Show),
+    Table(Table),
+    Truncate(Truncate),
+    Unlisten(Unlisten),
+    Update(Update),
+    Vacuum(Vacuum),
+    Values(Values),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum TableArg {
+    Column(Column),
+    LikeClause(LikeClause),
+    TableConstraint(TableConstraint),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum TableConstraint {
+    CheckConstraint(CheckConstraint),
+    ExcludeConstraint(ExcludeConstraint),
+    ForeignKeyConstraint(ForeignKeyConstraint),
+    PrimaryKeyConstraint(PrimaryKeyConstraint),
+    UniqueConstraint(UniqueConstraint),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Timezone {
+    WithTimezone(WithTimezone),
+    WithoutTimezone(WithoutTimezone),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum TransactionMode {
+    Deferrable(Deferrable),
+    NotDeferrable(NotDeferrable),
+    ReadCommitted(ReadCommitted),
+    ReadOnly(ReadOnly),
+    ReadUncommitted(ReadUncommitted),
+    ReadWrite(ReadWrite),
+    RepeatableRead(RepeatableRead),
+    Serializable(Serializable),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Type {
+    ArrayType(ArrayType),
+    BitType(BitType),
+    CharType(CharType),
+    DoubleType(DoubleType),
+    ExprType(ExprType),
+    IntervalType(IntervalType),
+    PathType(PathType),
+    PercentType(PercentType),
+    TimeType(TimeType),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum WithQuery {
+    CompoundSelect(CompoundSelect),
+    Delete(Delete),
+    Insert(Insert),
+    Merge(Merge),
+    ParenSelect(ParenSelect),
+    Select(Select),
+    Table(Table),
+    Update(Update),
+    Values(Values),
+}
+impl AstNode for AddColumn {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ADD_COLUMN
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AddConstraint {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ADD_CONSTRAINT
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AddGenerated {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ADD_GENERATED
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AddOpClassOptions {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ADD_OP_CLASS_OPTIONS
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for Aggregate {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::AGGREGATE
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for Alias {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALIAS
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AllFn {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALL_FN
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterAggregate {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_AGGREGATE
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterCollation {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_COLLATION
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterColumn {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_COLUMN
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterConstraint {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_CONSTRAINT
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterConversion {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_CONVERSION
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterDatabase {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_DATABASE
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterDefaultPrivileges {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_DEFAULT_PRIVILEGES
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterDomain {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_DOMAIN
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterEventTrigger {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_EVENT_TRIGGER
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterExtension {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_EXTENSION
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterForeignDataWrapper {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_FOREIGN_DATA_WRAPPER
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterForeignTable {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_FOREIGN_TABLE
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterFunction {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_FUNCTION
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterGroup {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_GROUP
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterIndex {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_INDEX
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterLanguage {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_LANGUAGE
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterLargeObject {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_LARGE_OBJECT
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterMaterializedView {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_MATERIALIZED_VIEW
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterOperator {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_OPERATOR
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterOperatorClass {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_OPERATOR_CLASS
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterOperatorFamily {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_OPERATOR_FAMILY
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterOption {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_OPTION
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterOptionList {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_OPTION_LIST
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterPolicy {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_POLICY
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterProcedure {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_PROCEDURE
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterPublication {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_PUBLICATION
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterRole {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_ROLE
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterRoutine {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_ROUTINE
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterRule {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_RULE
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterSchema {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_SCHEMA
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterSequence {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_SEQUENCE
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterServer {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_SERVER
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl AstNode for AlterSetStatistics {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_SET_STATISTICS
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
 }
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Type {
-    ArrayType(ArrayType),
-    BitType(BitType),
-    CharType(CharType),
-    DoubleType(DoubleType),
-    ExprType(ExprType),
-    IntervalType(IntervalType),
-    PathType(PathType),
-    PercentType(PercentType),
-    TimeType(TimeType),
+impl AstNode for AlterStatistics {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_STATISTICS
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
 }
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum WithQuery {
-    CompoundSelect(CompoundSelect),
-    Delete(Delete),
-    Insert(Insert),
-    Merge(Merge),
-    ParenSelect(ParenSelect),
-    Select(Select),
-    Table(Table),
-    Update(Update),
-    Values(Values),
+impl AstNode for AlterSubscription {
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == SyntaxKind::ALTER_SUBSCRIPTION
+    }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
 }
-impl AstNode for AddColumn {
+impl AstNode for AlterSystem {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ADD_COLUMN
+        kind == SyntaxKind::ALTER_SYSTEM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -14866,10 +17448,10 @@ impl AstNode for AddColumn {
         &self.syntax
     }
 }
-impl AstNode for AddConstraint {
+impl AstNode for AlterTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ADD_CONSTRAINT
+        kind == SyntaxKind::ALTER_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -14884,10 +17466,10 @@ impl AstNode for AddConstraint {
         &self.syntax
     }
 }
-impl AstNode for AddGenerated {
+impl AstNode for AlterTablespace {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ADD_GENERATED
+        kind == SyntaxKind::ALTER_TABLESPACE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -14902,10 +17484,10 @@ impl AstNode for AddGenerated {
         &self.syntax
     }
 }
-impl AstNode for AddOpClassOptions {
+impl AstNode for AlterTextSearchConfiguration {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ADD_OP_CLASS_OPTIONS
+        kind == SyntaxKind::ALTER_TEXT_SEARCH_CONFIGURATION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -14920,10 +17502,10 @@ impl AstNode for AddOpClassOptions {
         &self.syntax
     }
 }
-impl AstNode for Aggregate {
+impl AstNode for AlterTextSearchDictionary {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::AGGREGATE
+        kind == SyntaxKind::ALTER_TEXT_SEARCH_DICTIONARY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -14938,10 +17520,10 @@ impl AstNode for Aggregate {
         &self.syntax
     }
 }
-impl AstNode for Alias {
+impl AstNode for AlterTextSearchParser {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALIAS
+        kind == SyntaxKind::ALTER_TEXT_SEARCH_PARSER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -14956,10 +17538,10 @@ impl AstNode for Alias {
         &self.syntax
     }
 }
-impl AstNode for AlterAggregate {
+impl AstNode for AlterTextSearchTemplate {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_AGGREGATE
+        kind == SyntaxKind::ALTER_TEXT_SEARCH_TEMPLATE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -14974,10 +17556,10 @@ impl AstNode for AlterAggregate {
         &self.syntax
     }
 }
-impl AstNode for AlterCollation {
+impl AstNode for AlterTrigger {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_COLLATION
+        kind == SyntaxKind::ALTER_TRIGGER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -14992,10 +17574,10 @@ impl AstNode for AlterCollation {
         &self.syntax
     }
 }
-impl AstNode for AlterColumn {
+impl AstNode for AlterType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_COLUMN
+        kind == SyntaxKind::ALTER_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15010,10 +17592,10 @@ impl AstNode for AlterColumn {
         &self.syntax
     }
 }
-impl AstNode for AlterConstraint {
+impl AstNode for AlterUser {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_CONSTRAINT
+        kind == SyntaxKind::ALTER_USER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15028,10 +17610,10 @@ impl AstNode for AlterConstraint {
         &self.syntax
     }
 }
-impl AstNode for AlterConversion {
+impl AstNode for AlterUserMapping {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_CONVERSION
+        kind == SyntaxKind::ALTER_USER_MAPPING
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15046,10 +17628,10 @@ impl AstNode for AlterConversion {
         &self.syntax
     }
 }
-impl AstNode for AlterDatabase {
+impl AstNode for AlterView {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_DATABASE
+        kind == SyntaxKind::ALTER_VIEW
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15064,10 +17646,10 @@ impl AstNode for AlterDatabase {
         &self.syntax
     }
 }
-impl AstNode for AlterDefaultPrivileges {
+impl AstNode for Analyze {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_DEFAULT_PRIVILEGES
+        kind == SyntaxKind::ANALYZE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15082,10 +17664,10 @@ impl AstNode for AlterDefaultPrivileges {
         &self.syntax
     }
 }
-impl AstNode for AlterDomain {
+impl AstNode for AnyFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_DOMAIN
+        kind == SyntaxKind::ANY_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15100,10 +17682,10 @@ impl AstNode for AlterDomain {
         &self.syntax
     }
 }
-impl AstNode for AlterEventTrigger {
+impl AstNode for Arg {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_EVENT_TRIGGER
+        kind == SyntaxKind::ARG
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15118,10 +17700,10 @@ impl AstNode for AlterEventTrigger {
         &self.syntax
     }
 }
-impl AstNode for AlterExtension {
+impl AstNode for ArgList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_EXTENSION
+        kind == SyntaxKind::ARG_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15136,10 +17718,10 @@ impl AstNode for AlterExtension {
         &self.syntax
     }
 }
-impl AstNode for AlterForeignDataWrapper {
+impl AstNode for ArrayExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_FOREIGN_DATA_WRAPPER
+        kind == SyntaxKind::ARRAY_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15154,10 +17736,10 @@ impl AstNode for AlterForeignDataWrapper {
         &self.syntax
     }
 }
-impl AstNode for AlterForeignTable {
+impl AstNode for ArrayType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_FOREIGN_TABLE
+        kind == SyntaxKind::ARRAY_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15172,10 +17754,10 @@ impl AstNode for AlterForeignTable {
         &self.syntax
     }
 }
-impl AstNode for AlterFunction {
+impl AstNode for AsFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_FUNCTION
+        kind == SyntaxKind::AS_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15190,10 +17772,10 @@ impl AstNode for AlterFunction {
         &self.syntax
     }
 }
-impl AstNode for AlterGroup {
+impl AstNode for AsName {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_GROUP
+        kind == SyntaxKind::AS_NAME
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15208,10 +17790,10 @@ impl AstNode for AlterGroup {
         &self.syntax
     }
 }
-impl AstNode for AlterIndex {
+impl AstNode for AtTimeZone {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_INDEX
+        kind == SyntaxKind::AT_TIME_ZONE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15226,10 +17808,10 @@ impl AstNode for AlterIndex {
         &self.syntax
     }
 }
-impl AstNode for AlterLanguage {
+impl AstNode for AttachPartition {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_LANGUAGE
+        kind == SyntaxKind::ATTACH_PARTITION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15244,10 +17826,10 @@ impl AstNode for AlterLanguage {
         &self.syntax
     }
 }
-impl AstNode for AlterLargeObject {
+impl AstNode for AttributeList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_LARGE_OBJECT
+        kind == SyntaxKind::ATTRIBUTE_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15262,10 +17844,10 @@ impl AstNode for AlterLargeObject {
         &self.syntax
     }
 }
-impl AstNode for AlterMaterializedView {
+impl AstNode for AttributeOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_MATERIALIZED_VIEW
+        kind == SyntaxKind::ATTRIBUTE_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15280,10 +17862,10 @@ impl AstNode for AlterMaterializedView {
         &self.syntax
     }
 }
-impl AstNode for AlterOperator {
+impl AstNode for AttributeValue {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_OPERATOR
+        kind == SyntaxKind::ATTRIBUTE_VALUE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15298,10 +17880,10 @@ impl AstNode for AlterOperator {
         &self.syntax
     }
 }
-impl AstNode for AlterOperatorClass {
+impl AstNode for Begin {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_OPERATOR_CLASS
+        kind == SyntaxKind::BEGIN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15316,10 +17898,10 @@ impl AstNode for AlterOperatorClass {
         &self.syntax
     }
 }
-impl AstNode for AlterOperatorFamily {
+impl AstNode for BeginFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_OPERATOR_FAMILY
+        kind == SyntaxKind::BEGIN_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15334,10 +17916,10 @@ impl AstNode for AlterOperatorFamily {
         &self.syntax
     }
 }
-impl AstNode for AlterOption {
+impl AstNode for BetweenExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_OPTION
+        kind == SyntaxKind::BETWEEN_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15352,10 +17934,10 @@ impl AstNode for AlterOption {
         &self.syntax
     }
 }
-impl AstNode for AlterOptionList {
+impl AstNode for BinExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_OPTION_LIST
+        kind == SyntaxKind::BIN_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15370,10 +17952,10 @@ impl AstNode for AlterOptionList {
         &self.syntax
     }
 }
-impl AstNode for AlterPolicy {
+impl AstNode for BitType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_POLICY
+        kind == SyntaxKind::BIT_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15388,10 +17970,10 @@ impl AstNode for AlterPolicy {
         &self.syntax
     }
 }
-impl AstNode for AlterProcedure {
+impl AstNode for Call {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_PROCEDURE
+        kind == SyntaxKind::CALL
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15406,10 +17988,10 @@ impl AstNode for AlterProcedure {
         &self.syntax
     }
 }
-impl AstNode for AlterPublication {
+impl AstNode for CallExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_PUBLICATION
+        kind == SyntaxKind::CALL_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15424,10 +18006,10 @@ impl AstNode for AlterPublication {
         &self.syntax
     }
 }
-impl AstNode for AlterRole {
+impl AstNode for Cascade {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_ROLE
+        kind == SyntaxKind::CASCADE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15442,10 +18024,10 @@ impl AstNode for AlterRole {
         &self.syntax
     }
 }
-impl AstNode for AlterRoutine {
+impl AstNode for CaseExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_ROUTINE
+        kind == SyntaxKind::CASE_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15460,10 +18042,10 @@ impl AstNode for AlterRoutine {
         &self.syntax
     }
 }
-impl AstNode for AlterRule {
+impl AstNode for CastExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_RULE
+        kind == SyntaxKind::CAST_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15478,10 +18060,10 @@ impl AstNode for AlterRule {
         &self.syntax
     }
 }
-impl AstNode for AlterSchema {
+impl AstNode for CastSig {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_SCHEMA
+        kind == SyntaxKind::CAST_SIG
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15496,10 +18078,10 @@ impl AstNode for AlterSchema {
         &self.syntax
     }
 }
-impl AstNode for AlterSequence {
+impl AstNode for CharType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_SEQUENCE
+        kind == SyntaxKind::CHAR_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15514,10 +18096,10 @@ impl AstNode for AlterSequence {
         &self.syntax
     }
 }
-impl AstNode for AlterServer {
+impl AstNode for CheckConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_SERVER
+        kind == SyntaxKind::CHECK_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15532,10 +18114,10 @@ impl AstNode for AlterServer {
         &self.syntax
     }
 }
-impl AstNode for AlterSetStatistics {
+impl AstNode for Checkpoint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_SET_STATISTICS
+        kind == SyntaxKind::CHECKPOINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15550,10 +18132,10 @@ impl AstNode for AlterSetStatistics {
         &self.syntax
     }
 }
-impl AstNode for AlterStatistics {
+impl AstNode for Close {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_STATISTICS
+        kind == SyntaxKind::CLOSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15568,10 +18150,10 @@ impl AstNode for AlterStatistics {
         &self.syntax
     }
 }
-impl AstNode for AlterSubscription {
+impl AstNode for Cluster {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_SUBSCRIPTION
+        kind == SyntaxKind::CLUSTER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15586,10 +18168,10 @@ impl AstNode for AlterSubscription {
         &self.syntax
     }
 }
-impl AstNode for AlterSystem {
+impl AstNode for ClusterOn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_SYSTEM
+        kind == SyntaxKind::CLUSTER_ON
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15604,10 +18186,10 @@ impl AstNode for AlterSystem {
         &self.syntax
     }
 }
-impl AstNode for AlterTable {
+impl AstNode for Collate {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_TABLE
+        kind == SyntaxKind::COLLATE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15622,10 +18204,10 @@ impl AstNode for AlterTable {
         &self.syntax
     }
 }
-impl AstNode for AlterTablespace {
+impl AstNode for ColonColon {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_TABLESPACE
+        kind == SyntaxKind::COLON_COLON
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15640,10 +18222,10 @@ impl AstNode for AlterTablespace {
         &self.syntax
     }
 }
-impl AstNode for AlterTextSearchConfiguration {
+impl AstNode for ColonEq {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_TEXT_SEARCH_CONFIGURATION
+        kind == SyntaxKind::COLON_EQ
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15658,10 +18240,10 @@ impl AstNode for AlterTextSearchConfiguration {
         &self.syntax
     }
 }
-impl AstNode for AlterTextSearchDictionary {
+impl AstNode for Column {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_TEXT_SEARCH_DICTIONARY
+        kind == SyntaxKind::COLUMN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15676,10 +18258,10 @@ impl AstNode for AlterTextSearchDictionary {
         &self.syntax
     }
 }
-impl AstNode for AlterTextSearchParser {
+impl AstNode for ColumnList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_TEXT_SEARCH_PARSER
+        kind == SyntaxKind::COLUMN_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15694,10 +18276,10 @@ impl AstNode for AlterTextSearchParser {
         &self.syntax
     }
 }
-impl AstNode for AlterTextSearchTemplate {
+impl AstNode for CommentOn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_TEXT_SEARCH_TEMPLATE
+        kind == SyntaxKind::COMMENT_ON
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15712,10 +18294,10 @@ impl AstNode for AlterTextSearchTemplate {
         &self.syntax
     }
 }
-impl AstNode for AlterTrigger {
+impl AstNode for Commit {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_TRIGGER
+        kind == SyntaxKind::COMMIT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15730,10 +18312,10 @@ impl AstNode for AlterTrigger {
         &self.syntax
     }
 }
-impl AstNode for AlterType {
+impl AstNode for CompoundSelect {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_TYPE
+        kind == SyntaxKind::COMPOUND_SELECT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15748,10 +18330,10 @@ impl AstNode for AlterType {
         &self.syntax
     }
 }
-impl AstNode for AlterUser {
+impl AstNode for CompressionMethod {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_USER
+        kind == SyntaxKind::COMPRESSION_METHOD
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15766,10 +18348,10 @@ impl AstNode for AlterUser {
         &self.syntax
     }
 }
-impl AstNode for AlterUserMapping {
+impl AstNode for ConflictDoNothing {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_USER_MAPPING
+        kind == SyntaxKind::CONFLICT_DO_NOTHING
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15784,10 +18366,10 @@ impl AstNode for AlterUserMapping {
         &self.syntax
     }
 }
-impl AstNode for AlterView {
+impl AstNode for ConflictDoUpdateSet {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ALTER_VIEW
+        kind == SyntaxKind::CONFLICT_DO_UPDATE_SET
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15802,10 +18384,10 @@ impl AstNode for AlterView {
         &self.syntax
     }
 }
-impl AstNode for Analyze {
+impl AstNode for ConflictIndexItem {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ANALYZE
+        kind == SyntaxKind::CONFLICT_INDEX_ITEM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15820,10 +18402,10 @@ impl AstNode for Analyze {
         &self.syntax
     }
 }
-impl AstNode for Arg {
+impl AstNode for ConflictIndexItemList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ARG
+        kind == SyntaxKind::CONFLICT_INDEX_ITEM_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15838,10 +18420,10 @@ impl AstNode for Arg {
         &self.syntax
     }
 }
-impl AstNode for ArgList {
+impl AstNode for ConflictOnConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ARG_LIST
+        kind == SyntaxKind::CONFLICT_ON_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15856,10 +18438,10 @@ impl AstNode for ArgList {
         &self.syntax
     }
 }
-impl AstNode for ArrayExpr {
+impl AstNode for ConflictOnIndex {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ARRAY_EXPR
+        kind == SyntaxKind::CONFLICT_ON_INDEX
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15874,10 +18456,10 @@ impl AstNode for ArrayExpr {
         &self.syntax
     }
 }
-impl AstNode for ArrayType {
+impl AstNode for ConstraintExclusion {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ARRAY_TYPE
+        kind == SyntaxKind::CONSTRAINT_EXCLUSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15892,10 +18474,10 @@ impl AstNode for ArrayType {
         &self.syntax
     }
 }
-impl AstNode for AsFuncOption {
+impl AstNode for ConstraintExclusionList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::AS_FUNC_OPTION
+        kind == SyntaxKind::CONSTRAINT_EXCLUSION_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15910,10 +18492,10 @@ impl AstNode for AsFuncOption {
         &self.syntax
     }
 }
-impl AstNode for AsName {
+impl AstNode for ConstraintIncludeClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::AS_NAME
+        kind == SyntaxKind::CONSTRAINT_INCLUDE_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15928,10 +18510,10 @@ impl AstNode for AsName {
         &self.syntax
     }
 }
-impl AstNode for AtTimeZone {
+impl AstNode for ConstraintIndexMethod {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::AT_TIME_ZONE
+        kind == SyntaxKind::CONSTRAINT_INDEX_METHOD
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15946,10 +18528,10 @@ impl AstNode for AtTimeZone {
         &self.syntax
     }
 }
-impl AstNode for AttachPartition {
+impl AstNode for ConstraintIndexTablespace {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ATTACH_PARTITION
+        kind == SyntaxKind::CONSTRAINT_INDEX_TABLESPACE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15964,10 +18546,10 @@ impl AstNode for AttachPartition {
         &self.syntax
     }
 }
-impl AstNode for AttributeList {
+impl AstNode for Copy {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ATTRIBUTE_LIST
+        kind == SyntaxKind::COPY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -15982,10 +18564,10 @@ impl AstNode for AttributeList {
         &self.syntax
     }
 }
-impl AstNode for AttributeOption {
+impl AstNode for CostFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ATTRIBUTE_OPTION
+        kind == SyntaxKind::COST_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16000,10 +18582,10 @@ impl AstNode for AttributeOption {
         &self.syntax
     }
 }
-impl AstNode for AttributeValue {
+impl AstNode for CreateAccessMethod {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ATTRIBUTE_VALUE
+        kind == SyntaxKind::CREATE_ACCESS_METHOD
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16018,10 +18600,10 @@ impl AstNode for AttributeValue {
         &self.syntax
     }
 }
-impl AstNode for Begin {
+impl AstNode for CreateAggregate {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::BEGIN
+        kind == SyntaxKind::CREATE_AGGREGATE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16036,10 +18618,10 @@ impl AstNode for Begin {
         &self.syntax
     }
 }
-impl AstNode for BeginFuncOption {
+impl AstNode for CreateCast {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::BEGIN_FUNC_OPTION
+        kind == SyntaxKind::CREATE_CAST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16054,10 +18636,10 @@ impl AstNode for BeginFuncOption {
         &self.syntax
     }
 }
-impl AstNode for BetweenExpr {
+impl AstNode for CreateCollation {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::BETWEEN_EXPR
+        kind == SyntaxKind::CREATE_COLLATION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16072,10 +18654,10 @@ impl AstNode for BetweenExpr {
         &self.syntax
     }
 }
-impl AstNode for BinExpr {
+impl AstNode for CreateConversion {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::BIN_EXPR
+        kind == SyntaxKind::CREATE_CONVERSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16090,10 +18672,10 @@ impl AstNode for BinExpr {
         &self.syntax
     }
 }
-impl AstNode for BitType {
+impl AstNode for CreateDatabase {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::BIT_TYPE
+        kind == SyntaxKind::CREATE_DATABASE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16108,10 +18690,10 @@ impl AstNode for BitType {
         &self.syntax
     }
 }
-impl AstNode for Call {
+impl AstNode for CreateDatabaseOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CALL
+        kind == SyntaxKind::CREATE_DATABASE_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16126,10 +18708,10 @@ impl AstNode for Call {
         &self.syntax
     }
 }
-impl AstNode for CallExpr {
+impl AstNode for CreateDatabaseOptionList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CALL_EXPR
+        kind == SyntaxKind::CREATE_DATABASE_OPTION_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16144,10 +18726,10 @@ impl AstNode for CallExpr {
         &self.syntax
     }
 }
-impl AstNode for Cascade {
+impl AstNode for CreateDomain {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CASCADE
+        kind == SyntaxKind::CREATE_DOMAIN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16162,10 +18744,10 @@ impl AstNode for Cascade {
         &self.syntax
     }
 }
-impl AstNode for CaseExpr {
+impl AstNode for CreateEventTrigger {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CASE_EXPR
+        kind == SyntaxKind::CREATE_EVENT_TRIGGER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16180,10 +18762,10 @@ impl AstNode for CaseExpr {
         &self.syntax
     }
 }
-impl AstNode for CastExpr {
+impl AstNode for CreateExtension {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CAST_EXPR
+        kind == SyntaxKind::CREATE_EXTENSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16198,10 +18780,10 @@ impl AstNode for CastExpr {
         &self.syntax
     }
 }
-impl AstNode for CastSig {
+impl AstNode for CreateForeignDataWrapper {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CAST_SIG
+        kind == SyntaxKind::CREATE_FOREIGN_DATA_WRAPPER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16216,10 +18798,10 @@ impl AstNode for CastSig {
         &self.syntax
     }
 }
-impl AstNode for CharType {
+impl AstNode for CreateForeignTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CHAR_TYPE
+        kind == SyntaxKind::CREATE_FOREIGN_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16234,10 +18816,10 @@ impl AstNode for CharType {
         &self.syntax
     }
 }
-impl AstNode for CheckConstraint {
+impl AstNode for CreateFunction {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CHECK_CONSTRAINT
+        kind == SyntaxKind::CREATE_FUNCTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16252,10 +18834,10 @@ impl AstNode for CheckConstraint {
         &self.syntax
     }
 }
-impl AstNode for Checkpoint {
+impl AstNode for CreateGroup {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CHECKPOINT
+        kind == SyntaxKind::CREATE_GROUP
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16270,10 +18852,10 @@ impl AstNode for Checkpoint {
         &self.syntax
     }
 }
-impl AstNode for Close {
+impl AstNode for CreateIndex {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CLOSE
+        kind == SyntaxKind::CREATE_INDEX
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16288,10 +18870,10 @@ impl AstNode for Close {
         &self.syntax
     }
 }
-impl AstNode for Cluster {
+impl AstNode for CreateLanguage {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CLUSTER
+        kind == SyntaxKind::CREATE_LANGUAGE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16306,10 +18888,10 @@ impl AstNode for Cluster {
         &self.syntax
     }
 }
-impl AstNode for ClusterOn {
+impl AstNode for CreateMaterializedView {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CLUSTER_ON
+        kind == SyntaxKind::CREATE_MATERIALIZED_VIEW
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16324,10 +18906,10 @@ impl AstNode for ClusterOn {
         &self.syntax
     }
 }
-impl AstNode for Collate {
+impl AstNode for CreateOperator {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::COLLATE
+        kind == SyntaxKind::CREATE_OPERATOR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16342,10 +18924,10 @@ impl AstNode for Collate {
         &self.syntax
     }
 }
-impl AstNode for ColonColon {
+impl AstNode for CreateOperatorClass {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::COLON_COLON
+        kind == SyntaxKind::CREATE_OPERATOR_CLASS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16360,10 +18942,10 @@ impl AstNode for ColonColon {
         &self.syntax
     }
 }
-impl AstNode for ColonEq {
+impl AstNode for CreateOperatorFamily {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::COLON_EQ
+        kind == SyntaxKind::CREATE_OPERATOR_FAMILY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16378,10 +18960,10 @@ impl AstNode for ColonEq {
         &self.syntax
     }
 }
-impl AstNode for Column {
+impl AstNode for CreatePolicy {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::COLUMN
+        kind == SyntaxKind::CREATE_POLICY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16396,10 +18978,10 @@ impl AstNode for Column {
         &self.syntax
     }
 }
-impl AstNode for ColumnList {
+impl AstNode for CreateProcedure {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::COLUMN_LIST
+        kind == SyntaxKind::CREATE_PROCEDURE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16414,10 +18996,10 @@ impl AstNode for ColumnList {
         &self.syntax
     }
 }
-impl AstNode for CommentOn {
+impl AstNode for CreatePublication {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::COMMENT_ON
+        kind == SyntaxKind::CREATE_PUBLICATION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16432,10 +19014,10 @@ impl AstNode for CommentOn {
         &self.syntax
     }
 }
-impl AstNode for Commit {
+impl AstNode for CreateRole {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::COMMIT
+        kind == SyntaxKind::CREATE_ROLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16450,10 +19032,10 @@ impl AstNode for Commit {
         &self.syntax
     }
 }
-impl AstNode for CompoundSelect {
+impl AstNode for CreateRule {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::COMPOUND_SELECT
+        kind == SyntaxKind::CREATE_RULE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16468,10 +19050,10 @@ impl AstNode for CompoundSelect {
         &self.syntax
     }
 }
-impl AstNode for CompressionMethod {
+impl AstNode for CreateSchema {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::COMPRESSION_METHOD
+        kind == SyntaxKind::CREATE_SCHEMA
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16486,10 +19068,10 @@ impl AstNode for CompressionMethod {
         &self.syntax
     }
 }
-impl AstNode for ConflictDoNothing {
+impl AstNode for CreateSequence {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONFLICT_DO_NOTHING
+        kind == SyntaxKind::CREATE_SEQUENCE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16504,10 +19086,10 @@ impl AstNode for ConflictDoNothing {
         &self.syntax
     }
 }
-impl AstNode for ConflictDoUpdateSet {
+impl AstNode for CreateServer {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONFLICT_DO_UPDATE_SET
+        kind == SyntaxKind::CREATE_SERVER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16522,10 +19104,10 @@ impl AstNode for ConflictDoUpdateSet {
         &self.syntax
     }
 }
-impl AstNode for ConflictIndexItem {
+impl AstNode for CreateStatistics {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONFLICT_INDEX_ITEM
+        kind == SyntaxKind::CREATE_STATISTICS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16540,10 +19122,10 @@ impl AstNode for ConflictIndexItem {
         &self.syntax
     }
 }
-impl AstNode for ConflictIndexItemList {
+impl AstNode for CreateSubscription {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONFLICT_INDEX_ITEM_LIST
+        kind == SyntaxKind::CREATE_SUBSCRIPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16558,10 +19140,10 @@ impl AstNode for ConflictIndexItemList {
         &self.syntax
     }
 }
-impl AstNode for ConflictOnConstraint {
+impl AstNode for CreateTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONFLICT_ON_CONSTRAINT
+        kind == SyntaxKind::CREATE_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16576,10 +19158,10 @@ impl AstNode for ConflictOnConstraint {
         &self.syntax
     }
 }
-impl AstNode for ConflictOnIndex {
+impl AstNode for CreateTableAs {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONFLICT_ON_INDEX
+        kind == SyntaxKind::CREATE_TABLE_AS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16594,10 +19176,10 @@ impl AstNode for ConflictOnIndex {
         &self.syntax
     }
 }
-impl AstNode for ConstraintExclusion {
+impl AstNode for CreateTablespace {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONSTRAINT_EXCLUSION
+        kind == SyntaxKind::CREATE_TABLESPACE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16612,10 +19194,10 @@ impl AstNode for ConstraintExclusion {
         &self.syntax
     }
 }
-impl AstNode for ConstraintExclusionList {
+impl AstNode for CreateTextSearchConfiguration {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONSTRAINT_EXCLUSION_LIST
+        kind == SyntaxKind::CREATE_TEXT_SEARCH_CONFIGURATION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16630,10 +19212,10 @@ impl AstNode for ConstraintExclusionList {
         &self.syntax
     }
 }
-impl AstNode for ConstraintIncludeClause {
+impl AstNode for CreateTextSearchDictionary {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONSTRAINT_INCLUDE_CLAUSE
+        kind == SyntaxKind::CREATE_TEXT_SEARCH_DICTIONARY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16648,10 +19230,10 @@ impl AstNode for ConstraintIncludeClause {
         &self.syntax
     }
 }
-impl AstNode for ConstraintIndexMethod {
+impl AstNode for CreateTextSearchParser {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONSTRAINT_INDEX_METHOD
+        kind == SyntaxKind::CREATE_TEXT_SEARCH_PARSER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16666,10 +19248,10 @@ impl AstNode for ConstraintIndexMethod {
         &self.syntax
     }
 }
-impl AstNode for ConstraintIndexTablespace {
+impl AstNode for CreateTextSearchTemplate {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONSTRAINT_INDEX_TABLESPACE
+        kind == SyntaxKind::CREATE_TEXT_SEARCH_TEMPLATE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16684,10 +19266,10 @@ impl AstNode for ConstraintIndexTablespace {
         &self.syntax
     }
 }
-impl AstNode for ConstraintWhereClause {
+impl AstNode for CreateTransform {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CONSTRAINT_WHERE_CLAUSE
+        kind == SyntaxKind::CREATE_TRANSFORM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16702,10 +19284,10 @@ impl AstNode for ConstraintWhereClause {
         &self.syntax
     }
 }
-impl AstNode for Copy {
+impl AstNode for CreateTrigger {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::COPY
+        kind == SyntaxKind::CREATE_TRIGGER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16720,10 +19302,10 @@ impl AstNode for Copy {
         &self.syntax
     }
 }
-impl AstNode for CostFuncOption {
+impl AstNode for CreateType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::COST_FUNC_OPTION
+        kind == SyntaxKind::CREATE_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16738,10 +19320,10 @@ impl AstNode for CostFuncOption {
         &self.syntax
     }
 }
-impl AstNode for CreateAccessMethod {
+impl AstNode for CreateUser {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_ACCESS_METHOD
+        kind == SyntaxKind::CREATE_USER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16756,10 +19338,10 @@ impl AstNode for CreateAccessMethod {
         &self.syntax
     }
 }
-impl AstNode for CreateAggregate {
+impl AstNode for CreateUserMapping {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_AGGREGATE
+        kind == SyntaxKind::CREATE_USER_MAPPING
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16774,10 +19356,10 @@ impl AstNode for CreateAggregate {
         &self.syntax
     }
 }
-impl AstNode for CreateCast {
+impl AstNode for CreateView {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_CAST
+        kind == SyntaxKind::CREATE_VIEW
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16792,10 +19374,10 @@ impl AstNode for CreateCast {
         &self.syntax
     }
 }
-impl AstNode for CreateCollation {
+impl AstNode for CustomOp {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_COLLATION
+        kind == SyntaxKind::CUSTOM_OP
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16810,10 +19392,10 @@ impl AstNode for CreateCollation {
         &self.syntax
     }
 }
-impl AstNode for CreateConversion {
+impl AstNode for Deallocate {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_CONVERSION
+        kind == SyntaxKind::DEALLOCATE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16828,10 +19410,10 @@ impl AstNode for CreateConversion {
         &self.syntax
     }
 }
-impl AstNode for CreateDatabase {
+impl AstNode for Declare {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_DATABASE
+        kind == SyntaxKind::DECLARE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16846,10 +19428,10 @@ impl AstNode for CreateDatabase {
         &self.syntax
     }
 }
-impl AstNode for CreateDatabaseOption {
+impl AstNode for DefaultConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_DATABASE_OPTION
+        kind == SyntaxKind::DEFAULT_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16864,10 +19446,10 @@ impl AstNode for CreateDatabaseOption {
         &self.syntax
     }
 }
-impl AstNode for CreateDatabaseOptionList {
+impl AstNode for Deferrable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_DATABASE_OPTION_LIST
+        kind == SyntaxKind::DEFERRABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16882,10 +19464,10 @@ impl AstNode for CreateDatabaseOptionList {
         &self.syntax
     }
 }
-impl AstNode for CreateDomain {
+impl AstNode for DeferrableConstraintOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_DOMAIN
+        kind == SyntaxKind::DEFERRABLE_CONSTRAINT_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16900,10 +19482,10 @@ impl AstNode for CreateDomain {
         &self.syntax
     }
 }
-impl AstNode for CreateEventTrigger {
+impl AstNode for Delete {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_EVENT_TRIGGER
+        kind == SyntaxKind::DELETE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16918,10 +19500,10 @@ impl AstNode for CreateEventTrigger {
         &self.syntax
     }
 }
-impl AstNode for CreateExtension {
+impl AstNode for DeleteRows {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_EXTENSION
+        kind == SyntaxKind::DELETE_ROWS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16936,10 +19518,10 @@ impl AstNode for CreateExtension {
         &self.syntax
     }
 }
-impl AstNode for CreateForeignDataWrapper {
+impl AstNode for DependsOnExtension {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_FOREIGN_DATA_WRAPPER
+        kind == SyntaxKind::DEPENDS_ON_EXTENSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16954,10 +19536,10 @@ impl AstNode for CreateForeignDataWrapper {
         &self.syntax
     }
 }
-impl AstNode for CreateForeignTable {
+impl AstNode for DetachPartition {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_FOREIGN_TABLE
+        kind == SyntaxKind::DETACH_PARTITION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16972,10 +19554,10 @@ impl AstNode for CreateForeignTable {
         &self.syntax
     }
 }
-impl AstNode for CreateFunction {
+impl AstNode for DisableRls {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_FUNCTION
+        kind == SyntaxKind::DISABLE_RLS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -16990,10 +19572,10 @@ impl AstNode for CreateFunction {
         &self.syntax
     }
 }
-impl AstNode for CreateGroup {
+impl AstNode for DisableRule {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_GROUP
+        kind == SyntaxKind::DISABLE_RULE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17008,10 +19590,10 @@ impl AstNode for CreateGroup {
         &self.syntax
     }
 }
-impl AstNode for CreateIndex {
+impl AstNode for DisableTrigger {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_INDEX
+        kind == SyntaxKind::DISABLE_TRIGGER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17026,10 +19608,10 @@ impl AstNode for CreateIndex {
         &self.syntax
     }
 }
-impl AstNode for CreateLanguage {
+impl AstNode for Discard {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_LANGUAGE
+        kind == SyntaxKind::DISCARD
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17044,10 +19626,10 @@ impl AstNode for CreateLanguage {
         &self.syntax
     }
 }
-impl AstNode for CreateMaterializedView {
+impl AstNode for DistinctClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_MATERIALIZED_VIEW
+        kind == SyntaxKind::DISTINCT_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17062,10 +19644,10 @@ impl AstNode for CreateMaterializedView {
         &self.syntax
     }
 }
-impl AstNode for CreateOperator {
+impl AstNode for Do {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_OPERATOR
+        kind == SyntaxKind::DO
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17080,10 +19662,10 @@ impl AstNode for CreateOperator {
         &self.syntax
     }
 }
-impl AstNode for CreateOperatorClass {
+impl AstNode for DoubleType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_OPERATOR_CLASS
+        kind == SyntaxKind::DOUBLE_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17098,10 +19680,10 @@ impl AstNode for CreateOperatorClass {
         &self.syntax
     }
 }
-impl AstNode for CreateOperatorFamily {
+impl AstNode for Drop {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_OPERATOR_FAMILY
+        kind == SyntaxKind::DROP
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17116,10 +19698,10 @@ impl AstNode for CreateOperatorFamily {
         &self.syntax
     }
 }
-impl AstNode for CreatePolicy {
+impl AstNode for DropAccessMethod {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_POLICY
+        kind == SyntaxKind::DROP_ACCESS_METHOD
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17134,10 +19716,10 @@ impl AstNode for CreatePolicy {
         &self.syntax
     }
 }
-impl AstNode for CreateProcedure {
+impl AstNode for DropAggregate {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_PROCEDURE
+        kind == SyntaxKind::DROP_AGGREGATE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17152,10 +19734,10 @@ impl AstNode for CreateProcedure {
         &self.syntax
     }
 }
-impl AstNode for CreatePublication {
+impl AstNode for DropCast {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_PUBLICATION
+        kind == SyntaxKind::DROP_CAST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17170,10 +19752,10 @@ impl AstNode for CreatePublication {
         &self.syntax
     }
 }
-impl AstNode for CreateRole {
+impl AstNode for DropCollation {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_ROLE
+        kind == SyntaxKind::DROP_COLLATION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17188,10 +19770,10 @@ impl AstNode for CreateRole {
         &self.syntax
     }
 }
-impl AstNode for CreateRule {
+impl AstNode for DropColumn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_RULE
+        kind == SyntaxKind::DROP_COLUMN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17206,10 +19788,10 @@ impl AstNode for CreateRule {
         &self.syntax
     }
 }
-impl AstNode for CreateSchema {
+impl AstNode for DropConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_SCHEMA
+        kind == SyntaxKind::DROP_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17224,10 +19806,10 @@ impl AstNode for CreateSchema {
         &self.syntax
     }
 }
-impl AstNode for CreateSequence {
+impl AstNode for DropConversion {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_SEQUENCE
+        kind == SyntaxKind::DROP_CONVERSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17242,10 +19824,10 @@ impl AstNode for CreateSequence {
         &self.syntax
     }
 }
-impl AstNode for CreateServer {
+impl AstNode for DropDatabase {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_SERVER
+        kind == SyntaxKind::DROP_DATABASE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17260,10 +19842,10 @@ impl AstNode for CreateServer {
         &self.syntax
     }
 }
-impl AstNode for CreateStatistics {
+impl AstNode for DropDefault {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_STATISTICS
+        kind == SyntaxKind::DROP_DEFAULT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17278,10 +19860,10 @@ impl AstNode for CreateStatistics {
         &self.syntax
     }
 }
-impl AstNode for CreateSubscription {
+impl AstNode for DropDomain {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_SUBSCRIPTION
+        kind == SyntaxKind::DROP_DOMAIN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17296,10 +19878,10 @@ impl AstNode for CreateSubscription {
         &self.syntax
     }
 }
-impl AstNode for CreateTable {
+impl AstNode for DropEventTrigger {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_TABLE
+        kind == SyntaxKind::DROP_EVENT_TRIGGER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17314,10 +19896,10 @@ impl AstNode for CreateTable {
         &self.syntax
     }
 }
-impl AstNode for CreateTableAs {
+impl AstNode for DropExpression {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_TABLE_AS
+        kind == SyntaxKind::DROP_EXPRESSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17332,10 +19914,10 @@ impl AstNode for CreateTableAs {
         &self.syntax
     }
 }
-impl AstNode for CreateTablespace {
+impl AstNode for DropExtension {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_TABLESPACE
+        kind == SyntaxKind::DROP_EXTENSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17350,10 +19932,10 @@ impl AstNode for CreateTablespace {
         &self.syntax
     }
 }
-impl AstNode for CreateTextSearchConfiguration {
+impl AstNode for DropForeignDataWrapper {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_TEXT_SEARCH_CONFIGURATION
+        kind == SyntaxKind::DROP_FOREIGN_DATA_WRAPPER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17368,10 +19950,10 @@ impl AstNode for CreateTextSearchConfiguration {
         &self.syntax
     }
 }
-impl AstNode for CreateTextSearchDictionary {
+impl AstNode for DropForeignTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_TEXT_SEARCH_DICTIONARY
+        kind == SyntaxKind::DROP_FOREIGN_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17386,10 +19968,10 @@ impl AstNode for CreateTextSearchDictionary {
         &self.syntax
     }
 }
-impl AstNode for CreateTextSearchParser {
+impl AstNode for DropFunction {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_TEXT_SEARCH_PARSER
+        kind == SyntaxKind::DROP_FUNCTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17404,10 +19986,10 @@ impl AstNode for CreateTextSearchParser {
         &self.syntax
     }
 }
-impl AstNode for CreateTextSearchTemplate {
+impl AstNode for DropGroup {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_TEXT_SEARCH_TEMPLATE
+        kind == SyntaxKind::DROP_GROUP
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17422,10 +20004,10 @@ impl AstNode for CreateTextSearchTemplate {
         &self.syntax
     }
 }
-impl AstNode for CreateTransform {
+impl AstNode for DropIdentity {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_TRANSFORM
+        kind == SyntaxKind::DROP_IDENTITY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17440,10 +20022,10 @@ impl AstNode for CreateTransform {
         &self.syntax
     }
 }
-impl AstNode for CreateTrigger {
+impl AstNode for DropIndex {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_TRIGGER
+        kind == SyntaxKind::DROP_INDEX
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17458,10 +20040,10 @@ impl AstNode for CreateTrigger {
         &self.syntax
     }
 }
-impl AstNode for CreateType {
+impl AstNode for DropLanguage {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_TYPE
+        kind == SyntaxKind::DROP_LANGUAGE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17476,10 +20058,10 @@ impl AstNode for CreateType {
         &self.syntax
     }
 }
-impl AstNode for CreateUser {
+impl AstNode for DropMaterializedView {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_USER
+        kind == SyntaxKind::DROP_MATERIALIZED_VIEW
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17494,10 +20076,10 @@ impl AstNode for CreateUser {
         &self.syntax
     }
 }
-impl AstNode for CreateUserMapping {
+impl AstNode for DropNotNull {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_USER_MAPPING
+        kind == SyntaxKind::DROP_NOT_NULL
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17512,10 +20094,10 @@ impl AstNode for CreateUserMapping {
         &self.syntax
     }
 }
-impl AstNode for CreateView {
+impl AstNode for DropOpClassOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CREATE_VIEW
+        kind == SyntaxKind::DROP_OP_CLASS_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17530,10 +20112,10 @@ impl AstNode for CreateView {
         &self.syntax
     }
 }
-impl AstNode for CustomOp {
+impl AstNode for DropOpClassOptionList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::CUSTOM_OP
+        kind == SyntaxKind::DROP_OP_CLASS_OPTION_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17548,10 +20130,10 @@ impl AstNode for CustomOp {
         &self.syntax
     }
 }
-impl AstNode for Deallocate {
+impl AstNode for DropOpClassOptions {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DEALLOCATE
+        kind == SyntaxKind::DROP_OP_CLASS_OPTIONS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17566,10 +20148,10 @@ impl AstNode for Deallocate {
         &self.syntax
     }
 }
-impl AstNode for Declare {
+impl AstNode for DropOperator {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DECLARE
+        kind == SyntaxKind::DROP_OPERATOR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17584,10 +20166,10 @@ impl AstNode for Declare {
         &self.syntax
     }
 }
-impl AstNode for DefaultConstraint {
+impl AstNode for DropOperatorClass {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DEFAULT_CONSTRAINT
+        kind == SyntaxKind::DROP_OPERATOR_CLASS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17602,10 +20184,10 @@ impl AstNode for DefaultConstraint {
         &self.syntax
     }
 }
-impl AstNode for Deferrable {
+impl AstNode for DropOperatorFamily {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DEFERRABLE
+        kind == SyntaxKind::DROP_OPERATOR_FAMILY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17620,10 +20202,10 @@ impl AstNode for Deferrable {
         &self.syntax
     }
 }
-impl AstNode for DeferrableConstraintOption {
+impl AstNode for DropOwned {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DEFERRABLE_CONSTRAINT_OPTION
+        kind == SyntaxKind::DROP_OWNED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17638,10 +20220,10 @@ impl AstNode for DeferrableConstraintOption {
         &self.syntax
     }
 }
-impl AstNode for Delete {
+impl AstNode for DropPolicy {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DELETE
+        kind == SyntaxKind::DROP_POLICY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17656,10 +20238,10 @@ impl AstNode for Delete {
         &self.syntax
     }
 }
-impl AstNode for DeleteRows {
+impl AstNode for DropProcedure {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DELETE_ROWS
+        kind == SyntaxKind::DROP_PROCEDURE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17674,10 +20256,10 @@ impl AstNode for DeleteRows {
         &self.syntax
     }
 }
-impl AstNode for DependsOnExtension {
+impl AstNode for DropPublication {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DEPENDS_ON_EXTENSION
+        kind == SyntaxKind::DROP_PUBLICATION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17692,10 +20274,10 @@ impl AstNode for DependsOnExtension {
         &self.syntax
     }
 }
-impl AstNode for DetachPartition {
+impl AstNode for DropRole {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DETACH_PARTITION
+        kind == SyntaxKind::DROP_ROLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17710,10 +20292,10 @@ impl AstNode for DetachPartition {
         &self.syntax
     }
 }
-impl AstNode for DisableRls {
+impl AstNode for DropRoutine {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DISABLE_RLS
+        kind == SyntaxKind::DROP_ROUTINE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17728,10 +20310,10 @@ impl AstNode for DisableRls {
         &self.syntax
     }
 }
-impl AstNode for DisableRule {
+impl AstNode for DropRule {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DISABLE_RULE
+        kind == SyntaxKind::DROP_RULE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17746,10 +20328,10 @@ impl AstNode for DisableRule {
         &self.syntax
     }
 }
-impl AstNode for DisableTrigger {
+impl AstNode for DropSchema {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DISABLE_TRIGGER
+        kind == SyntaxKind::DROP_SCHEMA
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17764,10 +20346,10 @@ impl AstNode for DisableTrigger {
         &self.syntax
     }
 }
-impl AstNode for Discard {
+impl AstNode for DropSequence {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DISCARD
+        kind == SyntaxKind::DROP_SEQUENCE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17782,10 +20364,10 @@ impl AstNode for Discard {
         &self.syntax
     }
 }
-impl AstNode for DistinctClause {
+impl AstNode for DropServer {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DISTINCT_CLAUSE
+        kind == SyntaxKind::DROP_SERVER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17800,10 +20382,10 @@ impl AstNode for DistinctClause {
         &self.syntax
     }
 }
-impl AstNode for Do {
+impl AstNode for DropStatistics {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DO
+        kind == SyntaxKind::DROP_STATISTICS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17818,10 +20400,10 @@ impl AstNode for Do {
         &self.syntax
     }
 }
-impl AstNode for DoubleType {
+impl AstNode for DropSubscription {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DOUBLE_TYPE
+        kind == SyntaxKind::DROP_SUBSCRIPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17836,10 +20418,10 @@ impl AstNode for DoubleType {
         &self.syntax
     }
 }
-impl AstNode for Drop {
+impl AstNode for DropTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP
+        kind == SyntaxKind::DROP_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17854,10 +20436,10 @@ impl AstNode for Drop {
         &self.syntax
     }
 }
-impl AstNode for DropAccessMethod {
+impl AstNode for DropTablespace {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_ACCESS_METHOD
+        kind == SyntaxKind::DROP_TABLESPACE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17872,10 +20454,10 @@ impl AstNode for DropAccessMethod {
         &self.syntax
     }
 }
-impl AstNode for DropAggregate {
+impl AstNode for DropTextSearchConfig {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_AGGREGATE
+        kind == SyntaxKind::DROP_TEXT_SEARCH_CONFIG
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17890,10 +20472,10 @@ impl AstNode for DropAggregate {
         &self.syntax
     }
 }
-impl AstNode for DropCast {
+impl AstNode for DropTextSearchDict {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_CAST
+        kind == SyntaxKind::DROP_TEXT_SEARCH_DICT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17908,10 +20490,10 @@ impl AstNode for DropCast {
         &self.syntax
     }
 }
-impl AstNode for DropCollation {
+impl AstNode for DropTextSearchParser {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_COLLATION
+        kind == SyntaxKind::DROP_TEXT_SEARCH_PARSER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17926,10 +20508,10 @@ impl AstNode for DropCollation {
         &self.syntax
     }
 }
-impl AstNode for DropColumn {
+impl AstNode for DropTextSearchTemplate {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_COLUMN
+        kind == SyntaxKind::DROP_TEXT_SEARCH_TEMPLATE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17944,10 +20526,10 @@ impl AstNode for DropColumn {
         &self.syntax
     }
 }
-impl AstNode for DropConstraint {
+impl AstNode for DropTransform {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_CONSTRAINT
+        kind == SyntaxKind::DROP_TRANSFORM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17962,10 +20544,10 @@ impl AstNode for DropConstraint {
         &self.syntax
     }
 }
-impl AstNode for DropConversion {
+impl AstNode for DropTrigger {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_CONVERSION
+        kind == SyntaxKind::DROP_TRIGGER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17980,10 +20562,10 @@ impl AstNode for DropConversion {
         &self.syntax
     }
 }
-impl AstNode for DropDatabase {
+impl AstNode for DropType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_DATABASE
+        kind == SyntaxKind::DROP_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -17998,10 +20580,10 @@ impl AstNode for DropDatabase {
         &self.syntax
     }
 }
-impl AstNode for DropDefault {
+impl AstNode for DropUser {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_DEFAULT
+        kind == SyntaxKind::DROP_USER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18016,10 +20598,10 @@ impl AstNode for DropDefault {
         &self.syntax
     }
 }
-impl AstNode for DropDomain {
+impl AstNode for DropUserMapping {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_DOMAIN
+        kind == SyntaxKind::DROP_USER_MAPPING
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18034,10 +20616,10 @@ impl AstNode for DropDomain {
         &self.syntax
     }
 }
-impl AstNode for DropEventTrigger {
+impl AstNode for DropView {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_EVENT_TRIGGER
+        kind == SyntaxKind::DROP_VIEW
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18052,10 +20634,10 @@ impl AstNode for DropEventTrigger {
         &self.syntax
     }
 }
-impl AstNode for DropExpression {
+impl AstNode for ElseClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_EXPRESSION
+        kind == SyntaxKind::ELSE_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18070,10 +20652,10 @@ impl AstNode for DropExpression {
         &self.syntax
     }
 }
-impl AstNode for DropExtension {
+impl AstNode for EnableAlwaysRule {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_EXTENSION
+        kind == SyntaxKind::ENABLE_ALWAYS_RULE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18088,10 +20670,10 @@ impl AstNode for DropExtension {
         &self.syntax
     }
 }
-impl AstNode for DropForeignDataWrapper {
+impl AstNode for EnableAlwaysTrigger {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_FOREIGN_DATA_WRAPPER
+        kind == SyntaxKind::ENABLE_ALWAYS_TRIGGER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18106,10 +20688,10 @@ impl AstNode for DropForeignDataWrapper {
         &self.syntax
     }
 }
-impl AstNode for DropForeignTable {
+impl AstNode for EnableReplicaRule {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_FOREIGN_TABLE
+        kind == SyntaxKind::ENABLE_REPLICA_RULE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18124,10 +20706,10 @@ impl AstNode for DropForeignTable {
         &self.syntax
     }
 }
-impl AstNode for DropFunction {
+impl AstNode for EnableReplicaTrigger {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_FUNCTION
+        kind == SyntaxKind::ENABLE_REPLICA_TRIGGER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18142,10 +20724,10 @@ impl AstNode for DropFunction {
         &self.syntax
     }
 }
-impl AstNode for DropGroup {
+impl AstNode for EnableRls {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_GROUP
+        kind == SyntaxKind::ENABLE_RLS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18160,10 +20742,10 @@ impl AstNode for DropGroup {
         &self.syntax
     }
 }
-impl AstNode for DropIdentity {
+impl AstNode for EnableRule {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_IDENTITY
+        kind == SyntaxKind::ENABLE_RULE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18178,10 +20760,10 @@ impl AstNode for DropIdentity {
         &self.syntax
     }
 }
-impl AstNode for DropIndex {
+impl AstNode for EnableTrigger {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_INDEX
+        kind == SyntaxKind::ENABLE_TRIGGER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18196,10 +20778,10 @@ impl AstNode for DropIndex {
         &self.syntax
     }
 }
-impl AstNode for DropLanguage {
+impl AstNode for Enforced {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_LANGUAGE
+        kind == SyntaxKind::ENFORCED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18214,10 +20796,10 @@ impl AstNode for DropLanguage {
         &self.syntax
     }
 }
-impl AstNode for DropMaterializedView {
+impl AstNode for EventTriggerWhen {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_MATERIALIZED_VIEW
+        kind == SyntaxKind::EVENT_TRIGGER_WHEN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18232,10 +20814,10 @@ impl AstNode for DropMaterializedView {
         &self.syntax
     }
 }
-impl AstNode for DropNotNull {
+impl AstNode for EventTriggerWhenClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_NOT_NULL
+        kind == SyntaxKind::EVENT_TRIGGER_WHEN_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18250,10 +20832,10 @@ impl AstNode for DropNotNull {
         &self.syntax
     }
 }
-impl AstNode for DropOpClassOption {
+impl AstNode for ExceptTables {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_OP_CLASS_OPTION
+        kind == SyntaxKind::EXCEPT_TABLES
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18268,10 +20850,10 @@ impl AstNode for DropOpClassOption {
         &self.syntax
     }
 }
-impl AstNode for DropOpClassOptionList {
+impl AstNode for ExcludeConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_OP_CLASS_OPTION_LIST
+        kind == SyntaxKind::EXCLUDE_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18286,10 +20868,10 @@ impl AstNode for DropOpClassOptionList {
         &self.syntax
     }
 }
-impl AstNode for DropOpClassOptions {
+impl AstNode for Execute {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_OP_CLASS_OPTIONS
+        kind == SyntaxKind::EXECUTE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18304,10 +20886,10 @@ impl AstNode for DropOpClassOptions {
         &self.syntax
     }
 }
-impl AstNode for DropOperator {
+impl AstNode for ExistsFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_OPERATOR
+        kind == SyntaxKind::EXISTS_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18322,10 +20904,10 @@ impl AstNode for DropOperator {
         &self.syntax
     }
 }
-impl AstNode for DropOperatorClass {
+impl AstNode for Explain {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_OPERATOR_CLASS
+        kind == SyntaxKind::EXPLAIN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18340,10 +20922,10 @@ impl AstNode for DropOperatorClass {
         &self.syntax
     }
 }
-impl AstNode for DropOperatorFamily {
+impl AstNode for ExprAsName {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_OPERATOR_FAMILY
+        kind == SyntaxKind::EXPR_AS_NAME
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18358,10 +20940,10 @@ impl AstNode for DropOperatorFamily {
         &self.syntax
     }
 }
-impl AstNode for DropOwned {
+impl AstNode for ExprType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_OWNED
+        kind == SyntaxKind::EXPR_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18376,10 +20958,10 @@ impl AstNode for DropOwned {
         &self.syntax
     }
 }
-impl AstNode for DropPolicy {
+impl AstNode for ExtractFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_POLICY
+        kind == SyntaxKind::EXTRACT_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18394,10 +20976,10 @@ impl AstNode for DropPolicy {
         &self.syntax
     }
 }
-impl AstNode for DropProcedure {
+impl AstNode for FatArrow {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_PROCEDURE
+        kind == SyntaxKind::FAT_ARROW
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18412,10 +20994,10 @@ impl AstNode for DropProcedure {
         &self.syntax
     }
 }
-impl AstNode for DropPublication {
+impl AstNode for FdwOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_PUBLICATION
+        kind == SyntaxKind::FDW_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18430,10 +21012,10 @@ impl AstNode for DropPublication {
         &self.syntax
     }
 }
-impl AstNode for DropRole {
+impl AstNode for FdwOptionList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_ROLE
+        kind == SyntaxKind::FDW_OPTION_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18448,10 +21030,10 @@ impl AstNode for DropRole {
         &self.syntax
     }
 }
-impl AstNode for DropRoutine {
+impl AstNode for Fetch {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_ROUTINE
+        kind == SyntaxKind::FETCH
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18466,10 +21048,10 @@ impl AstNode for DropRoutine {
         &self.syntax
     }
 }
-impl AstNode for DropRule {
+impl AstNode for FetchClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_RULE
+        kind == SyntaxKind::FETCH_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18484,10 +21066,10 @@ impl AstNode for DropRule {
         &self.syntax
     }
 }
-impl AstNode for DropSchema {
+impl AstNode for FieldExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_SCHEMA
+        kind == SyntaxKind::FIELD_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18502,10 +21084,10 @@ impl AstNode for DropSchema {
         &self.syntax
     }
 }
-impl AstNode for DropSequence {
+impl AstNode for FilterClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_SEQUENCE
+        kind == SyntaxKind::FILTER_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18520,10 +21102,10 @@ impl AstNode for DropSequence {
         &self.syntax
     }
 }
-impl AstNode for DropServer {
+impl AstNode for ForProvider {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_SERVER
+        kind == SyntaxKind::FOR_PROVIDER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18538,10 +21120,10 @@ impl AstNode for DropServer {
         &self.syntax
     }
 }
-impl AstNode for DropStatistics {
+impl AstNode for ForceRls {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_STATISTICS
+        kind == SyntaxKind::FORCE_RLS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18556,10 +21138,10 @@ impl AstNode for DropStatistics {
         &self.syntax
     }
 }
-impl AstNode for DropSubscription {
+impl AstNode for ForeignKeyConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_SUBSCRIPTION
+        kind == SyntaxKind::FOREIGN_KEY_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18574,10 +21156,10 @@ impl AstNode for DropSubscription {
         &self.syntax
     }
 }
-impl AstNode for DropTable {
+impl AstNode for FrameClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_TABLE
+        kind == SyntaxKind::FRAME_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18592,10 +21174,10 @@ impl AstNode for DropTable {
         &self.syntax
     }
 }
-impl AstNode for DropTablespace {
+impl AstNode for FromClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_TABLESPACE
+        kind == SyntaxKind::FROM_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18610,10 +21192,10 @@ impl AstNode for DropTablespace {
         &self.syntax
     }
 }
-impl AstNode for DropTextSearchConfig {
+impl AstNode for FromItem {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_TEXT_SEARCH_CONFIG
+        kind == SyntaxKind::FROM_ITEM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18628,10 +21210,10 @@ impl AstNode for DropTextSearchConfig {
         &self.syntax
     }
 }
-impl AstNode for DropTextSearchDict {
+impl AstNode for FromServer {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_TEXT_SEARCH_DICT
+        kind == SyntaxKind::FROM_SERVER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18646,10 +21228,10 @@ impl AstNode for DropTextSearchDict {
         &self.syntax
     }
 }
-impl AstNode for DropTextSearchParser {
+impl AstNode for FromTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_TEXT_SEARCH_PARSER
+        kind == SyntaxKind::FROM_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18664,10 +21246,10 @@ impl AstNode for DropTextSearchParser {
         &self.syntax
     }
 }
-impl AstNode for DropTextSearchTemplate {
+impl AstNode for FuncOptionList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_TEXT_SEARCH_TEMPLATE
+        kind == SyntaxKind::FUNC_OPTION_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18682,10 +21264,10 @@ impl AstNode for DropTextSearchTemplate {
         &self.syntax
     }
 }
-impl AstNode for DropTransform {
+impl AstNode for FunctionSig {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_TRANSFORM
+        kind == SyntaxKind::FUNCTION_SIG
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18700,10 +21282,10 @@ impl AstNode for DropTransform {
         &self.syntax
     }
 }
-impl AstNode for DropTrigger {
+impl AstNode for FunctionSigList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_TRIGGER
+        kind == SyntaxKind::FUNCTION_SIG_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18718,10 +21300,10 @@ impl AstNode for DropTrigger {
         &self.syntax
     }
 }
-impl AstNode for DropType {
+impl AstNode for GeneratedConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_TYPE
+        kind == SyntaxKind::GENERATED_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18736,10 +21318,10 @@ impl AstNode for DropType {
         &self.syntax
     }
 }
-impl AstNode for DropUser {
+impl AstNode for Grant {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_USER
+        kind == SyntaxKind::GRANT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18754,10 +21336,10 @@ impl AstNode for DropUser {
         &self.syntax
     }
 }
-impl AstNode for DropUserMapping {
+impl AstNode for GrantDefaultPrivileges {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_USER_MAPPING
+        kind == SyntaxKind::GRANT_DEFAULT_PRIVILEGES
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18772,10 +21354,10 @@ impl AstNode for DropUserMapping {
         &self.syntax
     }
 }
-impl AstNode for DropView {
+impl AstNode for GroupByClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::DROP_VIEW
+        kind == SyntaxKind::GROUP_BY_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18790,10 +21372,10 @@ impl AstNode for DropView {
         &self.syntax
     }
 }
-impl AstNode for ElseClause {
+impl AstNode for GroupByList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ELSE_CLAUSE
+        kind == SyntaxKind::GROUP_BY_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18808,10 +21390,10 @@ impl AstNode for ElseClause {
         &self.syntax
     }
 }
-impl AstNode for EnableAlwaysRule {
+impl AstNode for GroupingCube {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ENABLE_ALWAYS_RULE
+        kind == SyntaxKind::GROUPING_CUBE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18826,10 +21408,10 @@ impl AstNode for EnableAlwaysRule {
         &self.syntax
     }
 }
-impl AstNode for EnableAlwaysTrigger {
+impl AstNode for GroupingExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ENABLE_ALWAYS_TRIGGER
+        kind == SyntaxKind::GROUPING_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18844,10 +21426,10 @@ impl AstNode for EnableAlwaysTrigger {
         &self.syntax
     }
 }
-impl AstNode for EnableReplicaRule {
+impl AstNode for GroupingRollup {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ENABLE_REPLICA_RULE
+        kind == SyntaxKind::GROUPING_ROLLUP
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18862,10 +21444,10 @@ impl AstNode for EnableReplicaRule {
         &self.syntax
     }
 }
-impl AstNode for EnableReplicaTrigger {
+impl AstNode for GroupingSets {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ENABLE_REPLICA_TRIGGER
+        kind == SyntaxKind::GROUPING_SETS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18880,10 +21462,10 @@ impl AstNode for EnableReplicaTrigger {
         &self.syntax
     }
 }
-impl AstNode for EnableRls {
+impl AstNode for Gteq {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ENABLE_RLS
+        kind == SyntaxKind::GTEQ
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18898,10 +21480,10 @@ impl AstNode for EnableRls {
         &self.syntax
     }
 }
-impl AstNode for EnableRule {
+impl AstNode for HandlerClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ENABLE_RULE
+        kind == SyntaxKind::HANDLER_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18916,10 +21498,10 @@ impl AstNode for EnableRule {
         &self.syntax
     }
 }
-impl AstNode for EnableTrigger {
+impl AstNode for HavingClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ENABLE_TRIGGER
+        kind == SyntaxKind::HAVING_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18934,10 +21516,10 @@ impl AstNode for EnableTrigger {
         &self.syntax
     }
 }
-impl AstNode for Enforced {
+impl AstNode for IfExists {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ENFORCED
+        kind == SyntaxKind::IF_EXISTS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18952,10 +21534,10 @@ impl AstNode for Enforced {
         &self.syntax
     }
 }
-impl AstNode for EventTriggerWhen {
+impl AstNode for IfNotExists {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::EVENT_TRIGGER_WHEN
+        kind == SyntaxKind::IF_NOT_EXISTS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18970,10 +21552,10 @@ impl AstNode for EventTriggerWhen {
         &self.syntax
     }
 }
-impl AstNode for EventTriggerWhenClause {
+impl AstNode for ImportForeignSchema {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::EVENT_TRIGGER_WHEN_CLAUSE
+        kind == SyntaxKind::IMPORT_FOREIGN_SCHEMA
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -18988,10 +21570,10 @@ impl AstNode for EventTriggerWhenClause {
         &self.syntax
     }
 }
-impl AstNode for ExceptTables {
+impl AstNode for IndexExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::EXCEPT_TABLES
+        kind == SyntaxKind::INDEX_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19006,10 +21588,10 @@ impl AstNode for ExceptTables {
         &self.syntax
     }
 }
-impl AstNode for ExcludeConstraint {
+impl AstNode for Inherit {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::EXCLUDE_CONSTRAINT
+        kind == SyntaxKind::INHERIT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19024,10 +21606,10 @@ impl AstNode for ExcludeConstraint {
         &self.syntax
     }
 }
-impl AstNode for Execute {
+impl AstNode for InheritTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::EXECUTE
+        kind == SyntaxKind::INHERIT_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19042,10 +21624,10 @@ impl AstNode for Execute {
         &self.syntax
     }
 }
-impl AstNode for Explain {
+impl AstNode for Inherits {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::EXPLAIN
+        kind == SyntaxKind::INHERITS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19060,10 +21642,10 @@ impl AstNode for Explain {
         &self.syntax
     }
 }
-impl AstNode for ExprType {
+impl AstNode for InitiallyDeferredConstraintOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::EXPR_TYPE
+        kind == SyntaxKind::INITIALLY_DEFERRED_CONSTRAINT_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19078,10 +21660,10 @@ impl AstNode for ExprType {
         &self.syntax
     }
 }
-impl AstNode for FatArrow {
+impl AstNode for InitiallyImmediateConstraintOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FAT_ARROW
+        kind == SyntaxKind::INITIALLY_IMMEDIATE_CONSTRAINT_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19096,10 +21678,10 @@ impl AstNode for FatArrow {
         &self.syntax
     }
 }
-impl AstNode for FdwOption {
+impl AstNode for Insert {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FDW_OPTION
+        kind == SyntaxKind::INSERT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19114,10 +21696,10 @@ impl AstNode for FdwOption {
         &self.syntax
     }
 }
-impl AstNode for FdwOptionList {
+impl AstNode for IntervalType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FDW_OPTION_LIST
+        kind == SyntaxKind::INTERVAL_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19132,10 +21714,10 @@ impl AstNode for FdwOptionList {
         &self.syntax
     }
 }
-impl AstNode for Fetch {
+impl AstNode for IntoClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FETCH
+        kind == SyntaxKind::INTO_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19150,10 +21732,10 @@ impl AstNode for Fetch {
         &self.syntax
     }
 }
-impl AstNode for FetchClause {
+impl AstNode for IntoSchema {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FETCH_CLAUSE
+        kind == SyntaxKind::INTO_SCHEMA
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19168,10 +21750,10 @@ impl AstNode for FetchClause {
         &self.syntax
     }
 }
-impl AstNode for FieldExpr {
+impl AstNode for IsDistinctFrom {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FIELD_EXPR
+        kind == SyntaxKind::IS_DISTINCT_FROM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19186,10 +21768,10 @@ impl AstNode for FieldExpr {
         &self.syntax
     }
 }
-impl AstNode for FilterClause {
+impl AstNode for IsJson {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FILTER_CLAUSE
+        kind == SyntaxKind::IS_JSON
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19204,10 +21786,10 @@ impl AstNode for FilterClause {
         &self.syntax
     }
 }
-impl AstNode for ForProvider {
+impl AstNode for IsJsonArray {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FOR_PROVIDER
+        kind == SyntaxKind::IS_JSON_ARRAY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19222,10 +21804,10 @@ impl AstNode for ForProvider {
         &self.syntax
     }
 }
-impl AstNode for ForceRls {
+impl AstNode for IsJsonObject {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FORCE_RLS
+        kind == SyntaxKind::IS_JSON_OBJECT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19240,10 +21822,10 @@ impl AstNode for ForceRls {
         &self.syntax
     }
 }
-impl AstNode for ForeignKeyConstraint {
+impl AstNode for IsJsonScalar {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FOREIGN_KEY_CONSTRAINT
+        kind == SyntaxKind::IS_JSON_SCALAR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19258,10 +21840,10 @@ impl AstNode for ForeignKeyConstraint {
         &self.syntax
     }
 }
-impl AstNode for FrameClause {
+impl AstNode for IsJsonValue {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FRAME_CLAUSE
+        kind == SyntaxKind::IS_JSON_VALUE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19276,10 +21858,10 @@ impl AstNode for FrameClause {
         &self.syntax
     }
 }
-impl AstNode for FromClause {
+impl AstNode for IsNormalized {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FROM_CLAUSE
+        kind == SyntaxKind::IS_NORMALIZED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19294,10 +21876,10 @@ impl AstNode for FromClause {
         &self.syntax
     }
 }
-impl AstNode for FromItem {
+impl AstNode for IsNot {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FROM_ITEM
+        kind == SyntaxKind::IS_NOT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19312,10 +21894,10 @@ impl AstNode for FromItem {
         &self.syntax
     }
 }
-impl AstNode for FromServer {
+impl AstNode for IsNotDistinctFrom {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FROM_SERVER
+        kind == SyntaxKind::IS_NOT_DISTINCT_FROM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19330,10 +21912,10 @@ impl AstNode for FromServer {
         &self.syntax
     }
 }
-impl AstNode for FromTable {
+impl AstNode for IsNotJson {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FROM_TABLE
+        kind == SyntaxKind::IS_NOT_JSON
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19348,10 +21930,10 @@ impl AstNode for FromTable {
         &self.syntax
     }
 }
-impl AstNode for FuncOptionList {
+impl AstNode for IsNotJsonArray {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FUNC_OPTION_LIST
+        kind == SyntaxKind::IS_NOT_JSON_ARRAY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19366,10 +21948,10 @@ impl AstNode for FuncOptionList {
         &self.syntax
     }
 }
-impl AstNode for FunctionSig {
+impl AstNode for IsNotJsonObject {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FUNCTION_SIG
+        kind == SyntaxKind::IS_NOT_JSON_OBJECT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19384,10 +21966,10 @@ impl AstNode for FunctionSig {
         &self.syntax
     }
 }
-impl AstNode for FunctionSigList {
+impl AstNode for IsNotJsonScalar {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::FUNCTION_SIG_LIST
+        kind == SyntaxKind::IS_NOT_JSON_SCALAR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19402,10 +21984,10 @@ impl AstNode for FunctionSigList {
         &self.syntax
     }
 }
-impl AstNode for GeneratedConstraint {
+impl AstNode for IsNotJsonValue {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::GENERATED_CONSTRAINT
+        kind == SyntaxKind::IS_NOT_JSON_VALUE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19420,10 +22002,10 @@ impl AstNode for GeneratedConstraint {
         &self.syntax
     }
 }
-impl AstNode for Grant {
+impl AstNode for IsNotNormalized {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::GRANT
+        kind == SyntaxKind::IS_NOT_NORMALIZED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19438,10 +22020,10 @@ impl AstNode for Grant {
         &self.syntax
     }
 }
-impl AstNode for GrantDefaultPrivileges {
+impl AstNode for Join {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::GRANT_DEFAULT_PRIVILEGES
+        kind == SyntaxKind::JOIN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19456,10 +22038,10 @@ impl AstNode for GrantDefaultPrivileges {
         &self.syntax
     }
 }
-impl AstNode for GroupByClause {
+impl AstNode for JoinCross {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::GROUP_BY_CLAUSE
+        kind == SyntaxKind::JOIN_CROSS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19474,10 +22056,10 @@ impl AstNode for GroupByClause {
         &self.syntax
     }
 }
-impl AstNode for GroupByList {
+impl AstNode for JoinExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::GROUP_BY_LIST
+        kind == SyntaxKind::JOIN_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19492,10 +22074,10 @@ impl AstNode for GroupByList {
         &self.syntax
     }
 }
-impl AstNode for GroupingCube {
+impl AstNode for JoinFull {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::GROUPING_CUBE
+        kind == SyntaxKind::JOIN_FULL
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19510,10 +22092,10 @@ impl AstNode for GroupingCube {
         &self.syntax
     }
 }
-impl AstNode for GroupingExpr {
+impl AstNode for JoinInner {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::GROUPING_EXPR
+        kind == SyntaxKind::JOIN_INNER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19528,10 +22110,10 @@ impl AstNode for GroupingExpr {
         &self.syntax
     }
 }
-impl AstNode for GroupingRollup {
+impl AstNode for JoinLeft {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::GROUPING_ROLLUP
+        kind == SyntaxKind::JOIN_LEFT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19546,10 +22128,10 @@ impl AstNode for GroupingRollup {
         &self.syntax
     }
 }
-impl AstNode for GroupingSets {
+impl AstNode for JoinRight {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::GROUPING_SETS
+        kind == SyntaxKind::JOIN_RIGHT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19564,10 +22146,10 @@ impl AstNode for GroupingSets {
         &self.syntax
     }
 }
-impl AstNode for Gteq {
+impl AstNode for JoinUsingClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::GTEQ
+        kind == SyntaxKind::JOIN_USING_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19582,10 +22164,10 @@ impl AstNode for Gteq {
         &self.syntax
     }
 }
-impl AstNode for HandlerClause {
+impl AstNode for JsonArrayAggFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::HANDLER_CLAUSE
+        kind == SyntaxKind::JSON_ARRAY_AGG_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19600,10 +22182,10 @@ impl AstNode for HandlerClause {
         &self.syntax
     }
 }
-impl AstNode for HavingClause {
+impl AstNode for JsonArrayFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::HAVING_CLAUSE
+        kind == SyntaxKind::JSON_ARRAY_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19618,10 +22200,10 @@ impl AstNode for HavingClause {
         &self.syntax
     }
 }
-impl AstNode for IfExists {
+impl AstNode for JsonBehaviorClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IF_EXISTS
+        kind == SyntaxKind::JSON_BEHAVIOR_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19636,10 +22218,10 @@ impl AstNode for IfExists {
         &self.syntax
     }
 }
-impl AstNode for IfNotExists {
+impl AstNode for JsonBehaviorDefault {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IF_NOT_EXISTS
+        kind == SyntaxKind::JSON_BEHAVIOR_DEFAULT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19654,10 +22236,10 @@ impl AstNode for IfNotExists {
         &self.syntax
     }
 }
-impl AstNode for ImportForeignSchema {
+impl AstNode for JsonBehaviorEmptyArray {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IMPORT_FOREIGN_SCHEMA
+        kind == SyntaxKind::JSON_BEHAVIOR_EMPTY_ARRAY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19672,10 +22254,10 @@ impl AstNode for ImportForeignSchema {
         &self.syntax
     }
 }
-impl AstNode for IndexExpr {
+impl AstNode for JsonBehaviorEmptyObject {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::INDEX_EXPR
+        kind == SyntaxKind::JSON_BEHAVIOR_EMPTY_OBJECT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19690,10 +22272,10 @@ impl AstNode for IndexExpr {
         &self.syntax
     }
 }
-impl AstNode for Inherit {
+impl AstNode for JsonBehaviorError {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::INHERIT
+        kind == SyntaxKind::JSON_BEHAVIOR_ERROR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19708,10 +22290,10 @@ impl AstNode for Inherit {
         &self.syntax
     }
 }
-impl AstNode for InheritTable {
+impl AstNode for JsonBehaviorFalse {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::INHERIT_TABLE
+        kind == SyntaxKind::JSON_BEHAVIOR_FALSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19726,10 +22308,10 @@ impl AstNode for InheritTable {
         &self.syntax
     }
 }
-impl AstNode for Inherits {
+impl AstNode for JsonBehaviorNull {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::INHERITS
+        kind == SyntaxKind::JSON_BEHAVIOR_NULL
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19744,10 +22326,10 @@ impl AstNode for Inherits {
         &self.syntax
     }
 }
-impl AstNode for InitiallyDeferredConstraintOption {
+impl AstNode for JsonBehaviorTrue {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::INITIALLY_DEFERRED_CONSTRAINT_OPTION
+        kind == SyntaxKind::JSON_BEHAVIOR_TRUE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19762,10 +22344,10 @@ impl AstNode for InitiallyDeferredConstraintOption {
         &self.syntax
     }
 }
-impl AstNode for InitiallyImmediateConstraintOption {
+impl AstNode for JsonBehaviorUnknown {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::INITIALLY_IMMEDIATE_CONSTRAINT_OPTION
+        kind == SyntaxKind::JSON_BEHAVIOR_UNKNOWN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19780,10 +22362,10 @@ impl AstNode for InitiallyImmediateConstraintOption {
         &self.syntax
     }
 }
-impl AstNode for Insert {
+impl AstNode for JsonEncodingClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::INSERT
+        kind == SyntaxKind::JSON_ENCODING_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19798,10 +22380,10 @@ impl AstNode for Insert {
         &self.syntax
     }
 }
-impl AstNode for IntervalType {
+impl AstNode for JsonExistsFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::INTERVAL_TYPE
+        kind == SyntaxKind::JSON_EXISTS_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19816,10 +22398,10 @@ impl AstNode for IntervalType {
         &self.syntax
     }
 }
-impl AstNode for IntoClause {
+impl AstNode for JsonExprFormat {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::INTO_CLAUSE
+        kind == SyntaxKind::JSON_EXPR_FORMAT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19834,10 +22416,10 @@ impl AstNode for IntoClause {
         &self.syntax
     }
 }
-impl AstNode for IntoSchema {
+impl AstNode for JsonFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::INTO_SCHEMA
+        kind == SyntaxKind::JSON_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19852,10 +22434,10 @@ impl AstNode for IntoSchema {
         &self.syntax
     }
 }
-impl AstNode for IsDistinctFrom {
+impl AstNode for JsonFormatClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_DISTINCT_FROM
+        kind == SyntaxKind::JSON_FORMAT_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19870,10 +22452,10 @@ impl AstNode for IsDistinctFrom {
         &self.syntax
     }
 }
-impl AstNode for IsJson {
+impl AstNode for JsonKeyValue {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_JSON
+        kind == SyntaxKind::JSON_KEY_VALUE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19888,10 +22470,10 @@ impl AstNode for IsJson {
         &self.syntax
     }
 }
-impl AstNode for IsJsonArray {
+impl AstNode for JsonKeysUniqueClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_JSON_ARRAY
+        kind == SyntaxKind::JSON_KEYS_UNIQUE_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19906,10 +22488,10 @@ impl AstNode for IsJsonArray {
         &self.syntax
     }
 }
-impl AstNode for IsJsonObject {
+impl AstNode for JsonNullClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_JSON_OBJECT
+        kind == SyntaxKind::JSON_NULL_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19924,10 +22506,10 @@ impl AstNode for IsJsonObject {
         &self.syntax
     }
 }
-impl AstNode for IsJsonScalar {
+impl AstNode for JsonObjectAggFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_JSON_SCALAR
+        kind == SyntaxKind::JSON_OBJECT_AGG_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19942,10 +22524,10 @@ impl AstNode for IsJsonScalar {
         &self.syntax
     }
 }
-impl AstNode for IsJsonValue {
+impl AstNode for JsonObjectFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_JSON_VALUE
+        kind == SyntaxKind::JSON_OBJECT_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19960,10 +22542,10 @@ impl AstNode for IsJsonValue {
         &self.syntax
     }
 }
-impl AstNode for IsNormalized {
+impl AstNode for JsonOnEmptyClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_NORMALIZED
+        kind == SyntaxKind::JSON_ON_EMPTY_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19978,10 +22560,10 @@ impl AstNode for IsNormalized {
         &self.syntax
     }
 }
-impl AstNode for IsNot {
+impl AstNode for JsonOnErrorClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_NOT
+        kind == SyntaxKind::JSON_ON_ERROR_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -19996,10 +22578,10 @@ impl AstNode for IsNot {
         &self.syntax
     }
 }
-impl AstNode for IsNotDistinctFrom {
+impl AstNode for JsonPassingArg {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_NOT_DISTINCT_FROM
+        kind == SyntaxKind::JSON_PASSING_ARG
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20014,10 +22596,10 @@ impl AstNode for IsNotDistinctFrom {
         &self.syntax
     }
 }
-impl AstNode for IsNotJson {
+impl AstNode for JsonPassingClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_NOT_JSON
+        kind == SyntaxKind::JSON_PASSING_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20032,10 +22614,10 @@ impl AstNode for IsNotJson {
         &self.syntax
     }
 }
-impl AstNode for IsNotJsonArray {
+impl AstNode for JsonPathClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_NOT_JSON_ARRAY
+        kind == SyntaxKind::JSON_PATH_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20050,10 +22632,10 @@ impl AstNode for IsNotJsonArray {
         &self.syntax
     }
 }
-impl AstNode for IsNotJsonObject {
+impl AstNode for JsonQueryFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_NOT_JSON_OBJECT
+        kind == SyntaxKind::JSON_QUERY_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20068,10 +22650,10 @@ impl AstNode for IsNotJsonObject {
         &self.syntax
     }
 }
-impl AstNode for IsNotJsonScalar {
+impl AstNode for JsonQuotesClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_NOT_JSON_SCALAR
+        kind == SyntaxKind::JSON_QUOTES_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20086,10 +22668,10 @@ impl AstNode for IsNotJsonScalar {
         &self.syntax
     }
 }
-impl AstNode for IsNotJsonValue {
+impl AstNode for JsonReturningClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_NOT_JSON_VALUE
+        kind == SyntaxKind::JSON_RETURNING_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20104,10 +22686,10 @@ impl AstNode for IsNotJsonValue {
         &self.syntax
     }
 }
-impl AstNode for IsNotNormalized {
+impl AstNode for JsonScalarFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::IS_NOT_NORMALIZED
+        kind == SyntaxKind::JSON_SCALAR_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20122,10 +22704,10 @@ impl AstNode for IsNotNormalized {
         &self.syntax
     }
 }
-impl AstNode for Join {
+impl AstNode for JsonSelectFormat {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JOIN
+        kind == SyntaxKind::JSON_SELECT_FORMAT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20140,10 +22722,10 @@ impl AstNode for Join {
         &self.syntax
     }
 }
-impl AstNode for JoinCross {
+impl AstNode for JsonSerializeFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JOIN_CROSS
+        kind == SyntaxKind::JSON_SERIALIZE_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20158,10 +22740,10 @@ impl AstNode for JoinCross {
         &self.syntax
     }
 }
-impl AstNode for JoinExpr {
+impl AstNode for JsonTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JOIN_EXPR
+        kind == SyntaxKind::JSON_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20176,10 +22758,10 @@ impl AstNode for JoinExpr {
         &self.syntax
     }
 }
-impl AstNode for JoinFull {
+impl AstNode for JsonTableColumn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JOIN_FULL
+        kind == SyntaxKind::JSON_TABLE_COLUMN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20194,10 +22776,10 @@ impl AstNode for JoinFull {
         &self.syntax
     }
 }
-impl AstNode for JoinInner {
+impl AstNode for JsonTableColumnList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JOIN_INNER
+        kind == SyntaxKind::JSON_TABLE_COLUMN_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20212,10 +22794,10 @@ impl AstNode for JoinInner {
         &self.syntax
     }
 }
-impl AstNode for JoinLeft {
+impl AstNode for JsonValueExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JOIN_LEFT
+        kind == SyntaxKind::JSON_VALUE_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20230,10 +22812,10 @@ impl AstNode for JoinLeft {
         &self.syntax
     }
 }
-impl AstNode for JoinRight {
+impl AstNode for JsonValueFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JOIN_RIGHT
+        kind == SyntaxKind::JSON_VALUE_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20248,10 +22830,10 @@ impl AstNode for JoinRight {
         &self.syntax
     }
 }
-impl AstNode for JoinUsingClause {
+impl AstNode for JsonWrapperBehaviorClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JOIN_USING_CLAUSE
+        kind == SyntaxKind::JSON_WRAPPER_BEHAVIOR_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20266,10 +22848,10 @@ impl AstNode for JoinUsingClause {
         &self.syntax
     }
 }
-impl AstNode for JsonBehaviorDefault {
+impl AstNode for LanguageFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_BEHAVIOR_DEFAULT
+        kind == SyntaxKind::LANGUAGE_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20284,10 +22866,10 @@ impl AstNode for JsonBehaviorDefault {
         &self.syntax
     }
 }
-impl AstNode for JsonBehaviorEmptyArray {
+impl AstNode for LeakproofFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_BEHAVIOR_EMPTY_ARRAY
+        kind == SyntaxKind::LEAKPROOF_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20302,10 +22884,10 @@ impl AstNode for JsonBehaviorEmptyArray {
         &self.syntax
     }
 }
-impl AstNode for JsonBehaviorEmptyObject {
+impl AstNode for LikeClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_BEHAVIOR_EMPTY_OBJECT
+        kind == SyntaxKind::LIKE_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20320,10 +22902,10 @@ impl AstNode for JsonBehaviorEmptyObject {
         &self.syntax
     }
 }
-impl AstNode for JsonBehaviorError {
+impl AstNode for LikeOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_BEHAVIOR_ERROR
+        kind == SyntaxKind::LIKE_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20338,10 +22920,10 @@ impl AstNode for JsonBehaviorError {
         &self.syntax
     }
 }
-impl AstNode for JsonBehaviorFalse {
+impl AstNode for LimitClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_BEHAVIOR_FALSE
+        kind == SyntaxKind::LIMIT_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20356,10 +22938,10 @@ impl AstNode for JsonBehaviorFalse {
         &self.syntax
     }
 }
-impl AstNode for JsonBehaviorNull {
+impl AstNode for LimitToTables {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_BEHAVIOR_NULL
+        kind == SyntaxKind::LIMIT_TO_TABLES
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20374,10 +22956,10 @@ impl AstNode for JsonBehaviorNull {
         &self.syntax
     }
 }
-impl AstNode for JsonBehaviorTrue {
+impl AstNode for Listen {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_BEHAVIOR_TRUE
+        kind == SyntaxKind::LISTEN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20392,10 +22974,10 @@ impl AstNode for JsonBehaviorTrue {
         &self.syntax
     }
 }
-impl AstNode for JsonBehaviorUnknown {
+impl AstNode for Literal {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_BEHAVIOR_UNKNOWN
+        kind == SyntaxKind::LITERAL
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20410,10 +22992,10 @@ impl AstNode for JsonBehaviorUnknown {
         &self.syntax
     }
 }
-impl AstNode for JsonFormatClause {
+impl AstNode for Load {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_FORMAT_CLAUSE
+        kind == SyntaxKind::LOAD
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20428,10 +23010,10 @@ impl AstNode for JsonFormatClause {
         &self.syntax
     }
 }
-impl AstNode for JsonKeyValue {
+impl AstNode for Lock {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_KEY_VALUE
+        kind == SyntaxKind::LOCK
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20446,10 +23028,10 @@ impl AstNode for JsonKeyValue {
         &self.syntax
     }
 }
-impl AstNode for JsonKeysUniqueClause {
+impl AstNode for LockingClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_KEYS_UNIQUE_CLAUSE
+        kind == SyntaxKind::LOCKING_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20464,10 +23046,10 @@ impl AstNode for JsonKeysUniqueClause {
         &self.syntax
     }
 }
-impl AstNode for JsonNullClause {
+impl AstNode for Lteq {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_NULL_CLAUSE
+        kind == SyntaxKind::LTEQ
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20482,10 +23064,10 @@ impl AstNode for JsonNullClause {
         &self.syntax
     }
 }
-impl AstNode for JsonOnEmptyClause {
+impl AstNode for MatchFull {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_ON_EMPTY_CLAUSE
+        kind == SyntaxKind::MATCH_FULL
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20500,10 +23082,10 @@ impl AstNode for JsonOnEmptyClause {
         &self.syntax
     }
 }
-impl AstNode for JsonOnErrorClause {
+impl AstNode for MatchPartial {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_ON_ERROR_CLAUSE
+        kind == SyntaxKind::MATCH_PARTIAL
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20518,10 +23100,10 @@ impl AstNode for JsonOnErrorClause {
         &self.syntax
     }
 }
-impl AstNode for JsonPassingArg {
+impl AstNode for MatchSimple {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_PASSING_ARG
+        kind == SyntaxKind::MATCH_SIMPLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20536,10 +23118,10 @@ impl AstNode for JsonPassingArg {
         &self.syntax
     }
 }
-impl AstNode for JsonPassingClause {
+impl AstNode for Materialized {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_PASSING_CLAUSE
+        kind == SyntaxKind::MATERIALIZED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20554,10 +23136,10 @@ impl AstNode for JsonPassingClause {
         &self.syntax
     }
 }
-impl AstNode for JsonQuotesClause {
+impl AstNode for Merge {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_QUOTES_CLAUSE
+        kind == SyntaxKind::MERGE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20572,10 +23154,10 @@ impl AstNode for JsonQuotesClause {
         &self.syntax
     }
 }
-impl AstNode for JsonReturningClause {
+impl AstNode for MergeDelete {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_RETURNING_CLAUSE
+        kind == SyntaxKind::MERGE_DELETE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20590,10 +23172,10 @@ impl AstNode for JsonReturningClause {
         &self.syntax
     }
 }
-impl AstNode for JsonTableColumn {
+impl AstNode for MergeDoNothing {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_TABLE_COLUMN
+        kind == SyntaxKind::MERGE_DO_NOTHING
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20608,10 +23190,10 @@ impl AstNode for JsonTableColumn {
         &self.syntax
     }
 }
-impl AstNode for JsonTableColumnList {
+impl AstNode for MergeInsert {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_TABLE_COLUMN_LIST
+        kind == SyntaxKind::MERGE_INSERT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20626,10 +23208,10 @@ impl AstNode for JsonTableColumnList {
         &self.syntax
     }
 }
-impl AstNode for JsonValueExpr {
+impl AstNode for MergeUpdate {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_VALUE_EXPR
+        kind == SyntaxKind::MERGE_UPDATE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20644,10 +23226,10 @@ impl AstNode for JsonValueExpr {
         &self.syntax
     }
 }
-impl AstNode for JsonWrapperBehaviorClause {
+impl AstNode for MergeWhenMatched {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::JSON_WRAPPER_BEHAVIOR_CLAUSE
+        kind == SyntaxKind::MERGE_WHEN_MATCHED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20662,10 +23244,10 @@ impl AstNode for JsonWrapperBehaviorClause {
         &self.syntax
     }
 }
-impl AstNode for LanguageFuncOption {
+impl AstNode for MergeWhenNotMatchedSource {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LANGUAGE_FUNC_OPTION
+        kind == SyntaxKind::MERGE_WHEN_NOT_MATCHED_SOURCE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20680,10 +23262,10 @@ impl AstNode for LanguageFuncOption {
         &self.syntax
     }
 }
-impl AstNode for LeakproofFuncOption {
+impl AstNode for MergeWhenNotMatchedTarget {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LEAKPROOF_FUNC_OPTION
+        kind == SyntaxKind::MERGE_WHEN_NOT_MATCHED_TARGET
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20698,10 +23280,10 @@ impl AstNode for LeakproofFuncOption {
         &self.syntax
     }
 }
-impl AstNode for LikeClause {
+impl AstNode for Move {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LIKE_CLAUSE
+        kind == SyntaxKind::MOVE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20716,10 +23298,10 @@ impl AstNode for LikeClause {
         &self.syntax
     }
 }
-impl AstNode for LikeOption {
+impl AstNode for Name {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LIKE_OPTION
+        kind == SyntaxKind::NAME
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20734,10 +23316,10 @@ impl AstNode for LikeOption {
         &self.syntax
     }
 }
-impl AstNode for LimitClause {
+impl AstNode for NameRef {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LIMIT_CLAUSE
+        kind == SyntaxKind::NAME_REF
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20752,10 +23334,10 @@ impl AstNode for LimitClause {
         &self.syntax
     }
 }
-impl AstNode for LimitToTables {
+impl AstNode for NamedArg {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LIMIT_TO_TABLES
+        kind == SyntaxKind::NAMED_ARG
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20770,10 +23352,10 @@ impl AstNode for LimitToTables {
         &self.syntax
     }
 }
-impl AstNode for Listen {
+impl AstNode for Neq {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LISTEN
+        kind == SyntaxKind::NEQ
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20788,10 +23370,10 @@ impl AstNode for Listen {
         &self.syntax
     }
 }
-impl AstNode for Literal {
+impl AstNode for Neqb {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LITERAL
+        kind == SyntaxKind::NEQB
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20806,10 +23388,10 @@ impl AstNode for Literal {
         &self.syntax
     }
 }
-impl AstNode for Load {
+impl AstNode for NoAction {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LOAD
+        kind == SyntaxKind::NO_ACTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20824,10 +23406,10 @@ impl AstNode for Load {
         &self.syntax
     }
 }
-impl AstNode for Lock {
+impl AstNode for NoDependsOnExtension {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LOCK
+        kind == SyntaxKind::NO_DEPENDS_ON_EXTENSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20842,10 +23424,10 @@ impl AstNode for Lock {
         &self.syntax
     }
 }
-impl AstNode for LockingClause {
+impl AstNode for NoForceRls {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LOCKING_CLAUSE
+        kind == SyntaxKind::NO_FORCE_RLS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20860,10 +23442,10 @@ impl AstNode for LockingClause {
         &self.syntax
     }
 }
-impl AstNode for Lteq {
+impl AstNode for NoInherit {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::LTEQ
+        kind == SyntaxKind::NO_INHERIT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20878,10 +23460,10 @@ impl AstNode for Lteq {
         &self.syntax
     }
 }
-impl AstNode for MatchFull {
+impl AstNode for NoInheritTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MATCH_FULL
+        kind == SyntaxKind::NO_INHERIT_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20896,10 +23478,10 @@ impl AstNode for MatchFull {
         &self.syntax
     }
 }
-impl AstNode for MatchPartial {
+impl AstNode for NonStandardParam {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MATCH_PARTIAL
+        kind == SyntaxKind::NON_STANDARD_PARAM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20914,10 +23496,10 @@ impl AstNode for MatchPartial {
         &self.syntax
     }
 }
-impl AstNode for MatchSimple {
+impl AstNode for NotDeferrable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MATCH_SIMPLE
+        kind == SyntaxKind::NOT_DEFERRABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20932,10 +23514,10 @@ impl AstNode for MatchSimple {
         &self.syntax
     }
 }
-impl AstNode for Materialized {
+impl AstNode for NotDeferrableConstraintOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MATERIALIZED
+        kind == SyntaxKind::NOT_DEFERRABLE_CONSTRAINT_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20950,10 +23532,10 @@ impl AstNode for Materialized {
         &self.syntax
     }
 }
-impl AstNode for Merge {
+impl AstNode for NotEnforced {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MERGE
+        kind == SyntaxKind::NOT_ENFORCED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20968,10 +23550,10 @@ impl AstNode for Merge {
         &self.syntax
     }
 }
-impl AstNode for MergeDelete {
+impl AstNode for NotIlike {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MERGE_DELETE
+        kind == SyntaxKind::NOT_ILIKE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -20986,10 +23568,10 @@ impl AstNode for MergeDelete {
         &self.syntax
     }
 }
-impl AstNode for MergeDoNothing {
+impl AstNode for NotIn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MERGE_DO_NOTHING
+        kind == SyntaxKind::NOT_IN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21004,10 +23586,10 @@ impl AstNode for MergeDoNothing {
         &self.syntax
     }
 }
-impl AstNode for MergeInsert {
+impl AstNode for NotLike {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MERGE_INSERT
+        kind == SyntaxKind::NOT_LIKE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21022,10 +23604,10 @@ impl AstNode for MergeInsert {
         &self.syntax
     }
 }
-impl AstNode for MergeUpdate {
+impl AstNode for NotMaterialized {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MERGE_UPDATE
+        kind == SyntaxKind::NOT_MATERIALIZED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21040,10 +23622,10 @@ impl AstNode for MergeUpdate {
         &self.syntax
     }
 }
-impl AstNode for MergeWhenMatched {
+impl AstNode for NotNullConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MERGE_WHEN_MATCHED
+        kind == SyntaxKind::NOT_NULL_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21058,10 +23640,10 @@ impl AstNode for MergeWhenMatched {
         &self.syntax
     }
 }
-impl AstNode for MergeWhenNotMatchedSource {
+impl AstNode for NotOf {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MERGE_WHEN_NOT_MATCHED_SOURCE
+        kind == SyntaxKind::NOT_OF
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21076,10 +23658,10 @@ impl AstNode for MergeWhenNotMatchedSource {
         &self.syntax
     }
 }
-impl AstNode for MergeWhenNotMatchedTarget {
+impl AstNode for NotSimilarTo {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MERGE_WHEN_NOT_MATCHED_TARGET
+        kind == SyntaxKind::NOT_SIMILAR_TO
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21094,10 +23676,10 @@ impl AstNode for MergeWhenNotMatchedTarget {
         &self.syntax
     }
 }
-impl AstNode for Move {
+impl AstNode for NotValid {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::MOVE
+        kind == SyntaxKind::NOT_VALID
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21112,10 +23694,10 @@ impl AstNode for Move {
         &self.syntax
     }
 }
-impl AstNode for Name {
+impl AstNode for Notify {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NAME
+        kind == SyntaxKind::NOTIFY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21130,10 +23712,10 @@ impl AstNode for Name {
         &self.syntax
     }
 }
-impl AstNode for NameRef {
+impl AstNode for NullConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NAME_REF
+        kind == SyntaxKind::NULL_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21148,10 +23730,10 @@ impl AstNode for NameRef {
         &self.syntax
     }
 }
-impl AstNode for NamedArg {
+impl AstNode for NullsDistinct {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NAMED_ARG
+        kind == SyntaxKind::NULLS_DISTINCT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21166,10 +23748,10 @@ impl AstNode for NamedArg {
         &self.syntax
     }
 }
-impl AstNode for Neq {
+impl AstNode for NullsFirst {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NEQ
+        kind == SyntaxKind::NULLS_FIRST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21184,10 +23766,10 @@ impl AstNode for Neq {
         &self.syntax
     }
 }
-impl AstNode for Neqb {
+impl AstNode for NullsLast {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NEQB
+        kind == SyntaxKind::NULLS_LAST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21202,10 +23784,10 @@ impl AstNode for Neqb {
         &self.syntax
     }
 }
-impl AstNode for NoAction {
+impl AstNode for NullsNotDistinct {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NO_ACTION
+        kind == SyntaxKind::NULLS_NOT_DISTINCT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21220,10 +23802,10 @@ impl AstNode for NoAction {
         &self.syntax
     }
 }
-impl AstNode for NoDependsOnExtension {
+impl AstNode for OfType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NO_DEPENDS_ON_EXTENSION
+        kind == SyntaxKind::OF_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21238,10 +23820,10 @@ impl AstNode for NoDependsOnExtension {
         &self.syntax
     }
 }
-impl AstNode for NoForceRls {
+impl AstNode for OffsetClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NO_FORCE_RLS
+        kind == SyntaxKind::OFFSET_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21256,10 +23838,10 @@ impl AstNode for NoForceRls {
         &self.syntax
     }
 }
-impl AstNode for NoInherit {
+impl AstNode for OnClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NO_INHERIT
+        kind == SyntaxKind::ON_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21274,10 +23856,10 @@ impl AstNode for NoInherit {
         &self.syntax
     }
 }
-impl AstNode for NoInheritTable {
+impl AstNode for OnCommit {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NO_INHERIT_TABLE
+        kind == SyntaxKind::ON_COMMIT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21292,10 +23874,10 @@ impl AstNode for NoInheritTable {
         &self.syntax
     }
 }
-impl AstNode for NonStandardParam {
+impl AstNode for OnConflictClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NON_STANDARD_PARAM
+        kind == SyntaxKind::ON_CONFLICT_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21310,10 +23892,10 @@ impl AstNode for NonStandardParam {
         &self.syntax
     }
 }
-impl AstNode for NotDeferrable {
+impl AstNode for OnDeleteAction {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOT_DEFERRABLE
+        kind == SyntaxKind::ON_DELETE_ACTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21328,10 +23910,10 @@ impl AstNode for NotDeferrable {
         &self.syntax
     }
 }
-impl AstNode for NotDeferrableConstraintOption {
+impl AstNode for OnTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOT_DEFERRABLE_CONSTRAINT_OPTION
+        kind == SyntaxKind::ON_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21346,10 +23928,10 @@ impl AstNode for NotDeferrableConstraintOption {
         &self.syntax
     }
 }
-impl AstNode for NotEnforced {
+impl AstNode for OnUpdateAction {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOT_ENFORCED
+        kind == SyntaxKind::ON_UPDATE_ACTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21364,10 +23946,10 @@ impl AstNode for NotEnforced {
         &self.syntax
     }
 }
-impl AstNode for NotIlike {
+impl AstNode for Op {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOT_ILIKE
+        kind == SyntaxKind::OP
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21382,10 +23964,10 @@ impl AstNode for NotIlike {
         &self.syntax
     }
 }
-impl AstNode for NotIn {
+impl AstNode for OpClassOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOT_IN
+        kind == SyntaxKind::OP_CLASS_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21400,10 +23982,10 @@ impl AstNode for NotIn {
         &self.syntax
     }
 }
-impl AstNode for NotLike {
+impl AstNode for OpSig {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOT_LIKE
+        kind == SyntaxKind::OP_SIG
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21418,10 +24000,10 @@ impl AstNode for NotLike {
         &self.syntax
     }
 }
-impl AstNode for NotMaterialized {
+impl AstNode for OpSigList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOT_MATERIALIZED
+        kind == SyntaxKind::OP_SIG_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21436,10 +24018,10 @@ impl AstNode for NotMaterialized {
         &self.syntax
     }
 }
-impl AstNode for NotNullConstraint {
+impl AstNode for OperatorCall {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOT_NULL_CONSTRAINT
+        kind == SyntaxKind::OPERATOR_CALL
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21454,10 +24036,10 @@ impl AstNode for NotNullConstraint {
         &self.syntax
     }
 }
-impl AstNode for NotOf {
+impl AstNode for OperatorClassOptionList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOT_OF
+        kind == SyntaxKind::OPERATOR_CLASS_OPTION_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21472,10 +24054,10 @@ impl AstNode for NotOf {
         &self.syntax
     }
 }
-impl AstNode for NotSimilarTo {
+impl AstNode for OptionItem {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOT_SIMILAR_TO
+        kind == SyntaxKind::OPTION_ITEM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21490,10 +24072,10 @@ impl AstNode for NotSimilarTo {
         &self.syntax
     }
 }
-impl AstNode for NotValid {
+impl AstNode for OptionItemList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOT_VALID
+        kind == SyntaxKind::OPTION_ITEM_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21508,10 +24090,10 @@ impl AstNode for NotValid {
         &self.syntax
     }
 }
-impl AstNode for Notify {
+impl AstNode for OrReplace {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NOTIFY
+        kind == SyntaxKind::OR_REPLACE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21526,10 +24108,10 @@ impl AstNode for Notify {
         &self.syntax
     }
 }
-impl AstNode for NullConstraint {
+impl AstNode for OrderByClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NULL_CONSTRAINT
+        kind == SyntaxKind::ORDER_BY_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21544,10 +24126,10 @@ impl AstNode for NullConstraint {
         &self.syntax
     }
 }
-impl AstNode for NullsDistinct {
+impl AstNode for OverClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NULLS_DISTINCT
+        kind == SyntaxKind::OVER_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21562,10 +24144,10 @@ impl AstNode for NullsDistinct {
         &self.syntax
     }
 }
-impl AstNode for NullsFirst {
+impl AstNode for OverlayFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NULLS_FIRST
+        kind == SyntaxKind::OVERLAY_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21580,10 +24162,10 @@ impl AstNode for NullsFirst {
         &self.syntax
     }
 }
-impl AstNode for NullsLast {
+impl AstNode for OwnerTo {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NULLS_LAST
+        kind == SyntaxKind::OWNER_TO
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21598,10 +24180,10 @@ impl AstNode for NullsLast {
         &self.syntax
     }
 }
-impl AstNode for NullsNotDistinct {
+impl AstNode for ParallelFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::NULLS_NOT_DISTINCT
+        kind == SyntaxKind::PARALLEL_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21616,10 +24198,10 @@ impl AstNode for NullsNotDistinct {
         &self.syntax
     }
 }
-impl AstNode for OfType {
+impl AstNode for Param {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OF_TYPE
+        kind == SyntaxKind::PARAM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21634,10 +24216,10 @@ impl AstNode for OfType {
         &self.syntax
     }
 }
-impl AstNode for OffsetClause {
+impl AstNode for ParamDefault {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OFFSET_CLAUSE
+        kind == SyntaxKind::PARAM_DEFAULT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21652,10 +24234,10 @@ impl AstNode for OffsetClause {
         &self.syntax
     }
 }
-impl AstNode for OnClause {
+impl AstNode for ParamIn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ON_CLAUSE
+        kind == SyntaxKind::PARAM_IN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21670,10 +24252,10 @@ impl AstNode for OnClause {
         &self.syntax
     }
 }
-impl AstNode for OnCommit {
+impl AstNode for ParamInOut {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ON_COMMIT
+        kind == SyntaxKind::PARAM_IN_OUT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21688,10 +24270,10 @@ impl AstNode for OnCommit {
         &self.syntax
     }
 }
-impl AstNode for OnConflictClause {
+impl AstNode for ParamList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ON_CONFLICT_CLAUSE
+        kind == SyntaxKind::PARAM_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21706,10 +24288,10 @@ impl AstNode for OnConflictClause {
         &self.syntax
     }
 }
-impl AstNode for OnDeleteAction {
+impl AstNode for ParamOut {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ON_DELETE_ACTION
+        kind == SyntaxKind::PARAM_OUT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21724,10 +24306,10 @@ impl AstNode for OnDeleteAction {
         &self.syntax
     }
 }
-impl AstNode for OnTable {
+impl AstNode for ParamVariadic {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ON_TABLE
+        kind == SyntaxKind::PARAM_VARIADIC
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21742,10 +24324,10 @@ impl AstNode for OnTable {
         &self.syntax
     }
 }
-impl AstNode for OnUpdateAction {
+impl AstNode for ParenExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ON_UPDATE_ACTION
+        kind == SyntaxKind::PAREN_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21760,10 +24342,10 @@ impl AstNode for OnUpdateAction {
         &self.syntax
     }
 }
-impl AstNode for Op {
+impl AstNode for ParenSelect {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OP
+        kind == SyntaxKind::PAREN_SELECT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21778,10 +24360,10 @@ impl AstNode for Op {
         &self.syntax
     }
 }
-impl AstNode for OpClassOption {
+impl AstNode for PartitionBy {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OP_CLASS_OPTION
+        kind == SyntaxKind::PARTITION_BY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21796,10 +24378,10 @@ impl AstNode for OpClassOption {
         &self.syntax
     }
 }
-impl AstNode for OpSig {
+impl AstNode for PartitionDefault {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OP_SIG
+        kind == SyntaxKind::PARTITION_DEFAULT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21814,10 +24396,10 @@ impl AstNode for OpSig {
         &self.syntax
     }
 }
-impl AstNode for OpSigList {
+impl AstNode for PartitionForValuesFrom {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OP_SIG_LIST
+        kind == SyntaxKind::PARTITION_FOR_VALUES_FROM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21832,10 +24414,10 @@ impl AstNode for OpSigList {
         &self.syntax
     }
 }
-impl AstNode for OperatorCall {
+impl AstNode for PartitionForValuesIn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OPERATOR_CALL
+        kind == SyntaxKind::PARTITION_FOR_VALUES_IN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21850,10 +24432,10 @@ impl AstNode for OperatorCall {
         &self.syntax
     }
 }
-impl AstNode for OperatorClassOptionList {
+impl AstNode for PartitionForValuesWith {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OPERATOR_CLASS_OPTION_LIST
+        kind == SyntaxKind::PARTITION_FOR_VALUES_WITH
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21868,10 +24450,10 @@ impl AstNode for OperatorClassOptionList {
         &self.syntax
     }
 }
-impl AstNode for OptionItem {
+impl AstNode for PartitionItem {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OPTION_ITEM
+        kind == SyntaxKind::PARTITION_ITEM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21886,10 +24468,10 @@ impl AstNode for OptionItem {
         &self.syntax
     }
 }
-impl AstNode for OptionItemList {
+impl AstNode for PartitionItemList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OPTION_ITEM_LIST
+        kind == SyntaxKind::PARTITION_ITEM_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21904,10 +24486,10 @@ impl AstNode for OptionItemList {
         &self.syntax
     }
 }
-impl AstNode for OrReplace {
+impl AstNode for PartitionOf {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OR_REPLACE
+        kind == SyntaxKind::PARTITION_OF
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21922,10 +24504,10 @@ impl AstNode for OrReplace {
         &self.syntax
     }
 }
-impl AstNode for OrderByClause {
+impl AstNode for Path {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ORDER_BY_CLAUSE
+        kind == SyntaxKind::PATH
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21940,10 +24522,10 @@ impl AstNode for OrderByClause {
         &self.syntax
     }
 }
-impl AstNode for OverClause {
+impl AstNode for PathSegment {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OVER_CLAUSE
+        kind == SyntaxKind::PATH_SEGMENT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21958,10 +24540,10 @@ impl AstNode for OverClause {
         &self.syntax
     }
 }
-impl AstNode for OwnerTo {
+impl AstNode for PathType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::OWNER_TO
+        kind == SyntaxKind::PATH_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21976,10 +24558,10 @@ impl AstNode for OwnerTo {
         &self.syntax
     }
 }
-impl AstNode for ParallelFuncOption {
+impl AstNode for PercentType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARALLEL_FUNC_OPTION
+        kind == SyntaxKind::PERCENT_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -21994,10 +24576,10 @@ impl AstNode for ParallelFuncOption {
         &self.syntax
     }
 }
-impl AstNode for Param {
+impl AstNode for PercentTypeClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARAM
+        kind == SyntaxKind::PERCENT_TYPE_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22012,10 +24594,10 @@ impl AstNode for Param {
         &self.syntax
     }
 }
-impl AstNode for ParamDefault {
+impl AstNode for PositionFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARAM_DEFAULT
+        kind == SyntaxKind::POSITION_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22030,10 +24612,10 @@ impl AstNode for ParamDefault {
         &self.syntax
     }
 }
-impl AstNode for ParamIn {
+impl AstNode for PostfixExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARAM_IN
+        kind == SyntaxKind::POSTFIX_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22048,10 +24630,10 @@ impl AstNode for ParamIn {
         &self.syntax
     }
 }
-impl AstNode for ParamInOut {
+impl AstNode for PrefixExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARAM_IN_OUT
+        kind == SyntaxKind::PREFIX_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22066,10 +24648,10 @@ impl AstNode for ParamInOut {
         &self.syntax
     }
 }
-impl AstNode for ParamList {
+impl AstNode for Prepare {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARAM_LIST
+        kind == SyntaxKind::PREPARE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22084,10 +24666,10 @@ impl AstNode for ParamList {
         &self.syntax
     }
 }
-impl AstNode for ParamOut {
+impl AstNode for PrepareTransaction {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARAM_OUT
+        kind == SyntaxKind::PREPARE_TRANSACTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22102,10 +24684,10 @@ impl AstNode for ParamOut {
         &self.syntax
     }
 }
-impl AstNode for ParamVariadic {
+impl AstNode for PreserveRows {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARAM_VARIADIC
+        kind == SyntaxKind::PRESERVE_ROWS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22120,10 +24702,10 @@ impl AstNode for ParamVariadic {
         &self.syntax
     }
 }
-impl AstNode for ParenExpr {
+impl AstNode for PrimaryKeyConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PAREN_EXPR
+        kind == SyntaxKind::PRIMARY_KEY_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22138,10 +24720,10 @@ impl AstNode for ParenExpr {
         &self.syntax
     }
 }
-impl AstNode for ParenSelect {
+impl AstNode for PrivilegeTarget {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PAREN_SELECT
+        kind == SyntaxKind::PRIVILEGE_TARGET
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22156,10 +24738,10 @@ impl AstNode for ParenSelect {
         &self.syntax
     }
 }
-impl AstNode for PartitionBy {
+impl AstNode for Privileges {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARTITION_BY
+        kind == SyntaxKind::PRIVILEGES
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22174,10 +24756,10 @@ impl AstNode for PartitionBy {
         &self.syntax
     }
 }
-impl AstNode for PartitionDefault {
+impl AstNode for PublicationObject {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARTITION_DEFAULT
+        kind == SyntaxKind::PUBLICATION_OBJECT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22192,10 +24774,10 @@ impl AstNode for PartitionDefault {
         &self.syntax
     }
 }
-impl AstNode for PartitionForValuesFrom {
+impl AstNode for ReadCommitted {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARTITION_FOR_VALUES_FROM
+        kind == SyntaxKind::READ_COMMITTED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22210,10 +24792,10 @@ impl AstNode for PartitionForValuesFrom {
         &self.syntax
     }
 }
-impl AstNode for PartitionForValuesIn {
+impl AstNode for ReadOnly {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARTITION_FOR_VALUES_IN
+        kind == SyntaxKind::READ_ONLY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22228,10 +24810,10 @@ impl AstNode for PartitionForValuesIn {
         &self.syntax
     }
 }
-impl AstNode for PartitionForValuesWith {
+impl AstNode for ReadUncommitted {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARTITION_FOR_VALUES_WITH
+        kind == SyntaxKind::READ_UNCOMMITTED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22246,10 +24828,10 @@ impl AstNode for PartitionForValuesWith {
         &self.syntax
     }
 }
-impl AstNode for PartitionItem {
+impl AstNode for ReadWrite {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARTITION_ITEM
+        kind == SyntaxKind::READ_WRITE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22264,10 +24846,10 @@ impl AstNode for PartitionItem {
         &self.syntax
     }
 }
-impl AstNode for PartitionItemList {
+impl AstNode for Reassign {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARTITION_ITEM_LIST
+        kind == SyntaxKind::REASSIGN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22282,10 +24864,10 @@ impl AstNode for PartitionItemList {
         &self.syntax
     }
 }
-impl AstNode for PartitionOf {
+impl AstNode for ReferencesConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PARTITION_OF
+        kind == SyntaxKind::REFERENCES_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22300,10 +24882,10 @@ impl AstNode for PartitionOf {
         &self.syntax
     }
 }
-impl AstNode for Path {
+impl AstNode for Referencing {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PATH
+        kind == SyntaxKind::REFERENCING
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22318,10 +24900,10 @@ impl AstNode for Path {
         &self.syntax
     }
 }
-impl AstNode for PathSegment {
+impl AstNode for ReferencingTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PATH_SEGMENT
+        kind == SyntaxKind::REFERENCING_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22336,10 +24918,10 @@ impl AstNode for PathSegment {
         &self.syntax
     }
 }
-impl AstNode for PathType {
+impl AstNode for Refresh {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PATH_TYPE
+        kind == SyntaxKind::REFRESH
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22354,10 +24936,10 @@ impl AstNode for PathType {
         &self.syntax
     }
 }
-impl AstNode for PercentType {
+impl AstNode for RefreshCollationVersion {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PERCENT_TYPE
+        kind == SyntaxKind::REFRESH_COLLATION_VERSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22372,10 +24954,10 @@ impl AstNode for PercentType {
         &self.syntax
     }
 }
-impl AstNode for PercentTypeClause {
+impl AstNode for RefreshVersion {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PERCENT_TYPE_CLAUSE
+        kind == SyntaxKind::REFRESH_VERSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22390,10 +24972,10 @@ impl AstNode for PercentTypeClause {
         &self.syntax
     }
 }
-impl AstNode for PostfixExpr {
+impl AstNode for Reindex {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::POSTFIX_EXPR
+        kind == SyntaxKind::REINDEX
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22408,10 +24990,10 @@ impl AstNode for PostfixExpr {
         &self.syntax
     }
 }
-impl AstNode for PrefixExpr {
+impl AstNode for RelationName {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PREFIX_EXPR
+        kind == SyntaxKind::RELATION_NAME
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22426,10 +25008,10 @@ impl AstNode for PrefixExpr {
         &self.syntax
     }
 }
-impl AstNode for Prepare {
+impl AstNode for ReleaseSavepoint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PREPARE
+        kind == SyntaxKind::RELEASE_SAVEPOINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22444,10 +25026,10 @@ impl AstNode for Prepare {
         &self.syntax
     }
 }
-impl AstNode for PrepareTransaction {
+impl AstNode for RenameColumn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PREPARE_TRANSACTION
+        kind == SyntaxKind::RENAME_COLUMN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22462,10 +25044,10 @@ impl AstNode for PrepareTransaction {
         &self.syntax
     }
 }
-impl AstNode for PreserveRows {
+impl AstNode for RenameConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PRESERVE_ROWS
+        kind == SyntaxKind::RENAME_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22480,10 +25062,10 @@ impl AstNode for PreserveRows {
         &self.syntax
     }
 }
-impl AstNode for PrimaryKeyConstraint {
+impl AstNode for RenameTo {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PRIMARY_KEY_CONSTRAINT
+        kind == SyntaxKind::RENAME_TO
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22498,10 +25080,10 @@ impl AstNode for PrimaryKeyConstraint {
         &self.syntax
     }
 }
-impl AstNode for PrivilegeTarget {
+impl AstNode for RepeatableClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PRIVILEGE_TARGET
+        kind == SyntaxKind::REPEATABLE_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22516,10 +25098,10 @@ impl AstNode for PrivilegeTarget {
         &self.syntax
     }
 }
-impl AstNode for Privileges {
+impl AstNode for RepeatableRead {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::PRIVILEGES
+        kind == SyntaxKind::REPEATABLE_READ
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22534,10 +25116,10 @@ impl AstNode for Privileges {
         &self.syntax
     }
 }
-impl AstNode for ReadCommitted {
+impl AstNode for ReplicaIdentity {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::READ_COMMITTED
+        kind == SyntaxKind::REPLICA_IDENTITY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22552,10 +25134,10 @@ impl AstNode for ReadCommitted {
         &self.syntax
     }
 }
-impl AstNode for ReadOnly {
+impl AstNode for Reset {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::READ_ONLY
+        kind == SyntaxKind::RESET
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22570,10 +25152,10 @@ impl AstNode for ReadOnly {
         &self.syntax
     }
 }
-impl AstNode for ReadUncommitted {
+impl AstNode for ResetConfigParam {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::READ_UNCOMMITTED
+        kind == SyntaxKind::RESET_CONFIG_PARAM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22588,10 +25170,10 @@ impl AstNode for ReadUncommitted {
         &self.syntax
     }
 }
-impl AstNode for ReadWrite {
+impl AstNode for ResetFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::READ_WRITE
+        kind == SyntaxKind::RESET_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22606,10 +25188,10 @@ impl AstNode for ReadWrite {
         &self.syntax
     }
 }
-impl AstNode for Reassign {
+impl AstNode for ResetOptions {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REASSIGN
+        kind == SyntaxKind::RESET_OPTIONS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22624,10 +25206,10 @@ impl AstNode for Reassign {
         &self.syntax
     }
 }
-impl AstNode for ReferencesConstraint {
+impl AstNode for ResetSessionAuth {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REFERENCES_CONSTRAINT
+        kind == SyntaxKind::RESET_SESSION_AUTH
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22642,10 +25224,10 @@ impl AstNode for ReferencesConstraint {
         &self.syntax
     }
 }
-impl AstNode for Referencing {
+impl AstNode for Restart {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REFERENCING
+        kind == SyntaxKind::RESTART
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22660,10 +25242,10 @@ impl AstNode for Referencing {
         &self.syntax
     }
 }
-impl AstNode for ReferencingTable {
+impl AstNode for Restrict {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REFERENCING_TABLE
+        kind == SyntaxKind::RESTRICT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22678,10 +25260,10 @@ impl AstNode for ReferencingTable {
         &self.syntax
     }
 }
-impl AstNode for Refresh {
+impl AstNode for RetType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REFRESH
+        kind == SyntaxKind::RET_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22696,10 +25278,10 @@ impl AstNode for Refresh {
         &self.syntax
     }
 }
-impl AstNode for RefreshCollationVersion {
+impl AstNode for ReturnFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REFRESH_COLLATION_VERSION
+        kind == SyntaxKind::RETURN_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22714,10 +25296,10 @@ impl AstNode for RefreshCollationVersion {
         &self.syntax
     }
 }
-impl AstNode for RefreshVersion {
+impl AstNode for ReturningClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REFRESH_VERSION
+        kind == SyntaxKind::RETURNING_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22732,10 +25314,10 @@ impl AstNode for RefreshVersion {
         &self.syntax
     }
 }
-impl AstNode for Reindex {
+impl AstNode for ReturningOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REINDEX
+        kind == SyntaxKind::RETURNING_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22750,10 +25332,10 @@ impl AstNode for Reindex {
         &self.syntax
     }
 }
-impl AstNode for RelationName {
+impl AstNode for ReturningOptionList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RELATION_NAME
+        kind == SyntaxKind::RETURNING_OPTION_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22768,10 +25350,10 @@ impl AstNode for RelationName {
         &self.syntax
     }
 }
-impl AstNode for ReleaseSavepoint {
+impl AstNode for Revoke {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RELEASE_SAVEPOINT
+        kind == SyntaxKind::REVOKE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22786,10 +25368,10 @@ impl AstNode for ReleaseSavepoint {
         &self.syntax
     }
 }
-impl AstNode for RenameColumn {
+impl AstNode for RevokeCommand {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RENAME_COLUMN
+        kind == SyntaxKind::REVOKE_COMMAND
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22804,10 +25386,10 @@ impl AstNode for RenameColumn {
         &self.syntax
     }
 }
-impl AstNode for RenameConstraint {
+impl AstNode for RevokeCommandList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RENAME_CONSTRAINT
+        kind == SyntaxKind::REVOKE_COMMAND_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22822,10 +25404,10 @@ impl AstNode for RenameConstraint {
         &self.syntax
     }
 }
-impl AstNode for RenameTo {
+impl AstNode for RevokeDefaultPrivileges {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RENAME_TO
+        kind == SyntaxKind::REVOKE_DEFAULT_PRIVILEGES
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22840,10 +25422,10 @@ impl AstNode for RenameTo {
         &self.syntax
     }
 }
-impl AstNode for RepeatableRead {
+impl AstNode for Role {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REPEATABLE_READ
+        kind == SyntaxKind::ROLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22858,10 +25440,10 @@ impl AstNode for RepeatableRead {
         &self.syntax
     }
 }
-impl AstNode for ReplicaIdentity {
+impl AstNode for RoleList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REPLICA_IDENTITY
+        kind == SyntaxKind::ROLE_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22876,10 +25458,10 @@ impl AstNode for ReplicaIdentity {
         &self.syntax
     }
 }
-impl AstNode for Reset {
+impl AstNode for RoleOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RESET
+        kind == SyntaxKind::ROLE_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22894,10 +25476,10 @@ impl AstNode for Reset {
         &self.syntax
     }
 }
-impl AstNode for ResetConfigParam {
+impl AstNode for RoleOptionList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RESET_CONFIG_PARAM
+        kind == SyntaxKind::ROLE_OPTION_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22912,10 +25494,10 @@ impl AstNode for ResetConfigParam {
         &self.syntax
     }
 }
-impl AstNode for ResetFuncOption {
+impl AstNode for Rollback {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RESET_FUNC_OPTION
+        kind == SyntaxKind::ROLLBACK
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22930,10 +25512,10 @@ impl AstNode for ResetFuncOption {
         &self.syntax
     }
 }
-impl AstNode for ResetOptions {
+impl AstNode for Row {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RESET_OPTIONS
+        kind == SyntaxKind::ROW
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22948,10 +25530,10 @@ impl AstNode for ResetOptions {
         &self.syntax
     }
 }
-impl AstNode for ResetSessionAuth {
+impl AstNode for RowList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RESET_SESSION_AUTH
+        kind == SyntaxKind::ROW_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22966,10 +25548,10 @@ impl AstNode for ResetSessionAuth {
         &self.syntax
     }
 }
-impl AstNode for Restart {
+impl AstNode for RowsFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RESTART
+        kind == SyntaxKind::ROWS_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -22984,10 +25566,10 @@ impl AstNode for Restart {
         &self.syntax
     }
 }
-impl AstNode for Restrict {
+impl AstNode for Savepoint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RESTRICT
+        kind == SyntaxKind::SAVEPOINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23002,10 +25584,10 @@ impl AstNode for Restrict {
         &self.syntax
     }
 }
-impl AstNode for RetType {
+impl AstNode for SchemaAuthorization {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RET_TYPE
+        kind == SyntaxKind::SCHEMA_AUTHORIZATION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23020,10 +25602,10 @@ impl AstNode for RetType {
         &self.syntax
     }
 }
-impl AstNode for ReturnFuncOption {
+impl AstNode for SecurityFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RETURN_FUNC_OPTION
+        kind == SyntaxKind::SECURITY_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23038,10 +25620,10 @@ impl AstNode for ReturnFuncOption {
         &self.syntax
     }
 }
-impl AstNode for ReturningClause {
+impl AstNode for SecurityLabel {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RETURNING_CLAUSE
+        kind == SyntaxKind::SECURITY_LABEL
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23056,10 +25638,10 @@ impl AstNode for ReturningClause {
         &self.syntax
     }
 }
-impl AstNode for ReturningOption {
+impl AstNode for Select {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RETURNING_OPTION
+        kind == SyntaxKind::SELECT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23074,10 +25656,10 @@ impl AstNode for ReturningOption {
         &self.syntax
     }
 }
-impl AstNode for ReturningOptionList {
+impl AstNode for SelectClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::RETURNING_OPTION_LIST
+        kind == SyntaxKind::SELECT_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23092,10 +25674,10 @@ impl AstNode for ReturningOptionList {
         &self.syntax
     }
 }
-impl AstNode for Revoke {
+impl AstNode for SelectInto {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REVOKE
+        kind == SyntaxKind::SELECT_INTO
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23110,10 +25692,10 @@ impl AstNode for Revoke {
         &self.syntax
     }
 }
-impl AstNode for RevokeCommand {
+impl AstNode for SequenceOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REVOKE_COMMAND
+        kind == SyntaxKind::SEQUENCE_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23128,10 +25710,10 @@ impl AstNode for RevokeCommand {
         &self.syntax
     }
 }
-impl AstNode for RevokeCommandList {
+impl AstNode for SequenceOptionList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REVOKE_COMMAND_LIST
+        kind == SyntaxKind::SEQUENCE_OPTION_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23146,10 +25728,10 @@ impl AstNode for RevokeCommandList {
         &self.syntax
     }
 }
-impl AstNode for RevokeDefaultPrivileges {
+impl AstNode for Serializable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::REVOKE_DEFAULT_PRIVILEGES
+        kind == SyntaxKind::SERIALIZABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23164,10 +25746,10 @@ impl AstNode for RevokeDefaultPrivileges {
         &self.syntax
     }
 }
-impl AstNode for Role {
+impl AstNode for Set {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ROLE
+        kind == SyntaxKind::SET
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23182,10 +25764,10 @@ impl AstNode for Role {
         &self.syntax
     }
 }
-impl AstNode for RoleList {
+impl AstNode for SetAccessMethod {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ROLE_LIST
+        kind == SyntaxKind::SET_ACCESS_METHOD
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23200,10 +25782,10 @@ impl AstNode for RoleList {
         &self.syntax
     }
 }
-impl AstNode for RoleOption {
+impl AstNode for SetClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ROLE_OPTION
+        kind == SyntaxKind::SET_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23218,10 +25800,10 @@ impl AstNode for RoleOption {
         &self.syntax
     }
 }
-impl AstNode for RoleOptionList {
+impl AstNode for SetColumnList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ROLE_OPTION_LIST
+        kind == SyntaxKind::SET_COLUMN_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23236,10 +25818,10 @@ impl AstNode for RoleOptionList {
         &self.syntax
     }
 }
-impl AstNode for Rollback {
+impl AstNode for SetCompression {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ROLLBACK
+        kind == SyntaxKind::SET_COMPRESSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23254,10 +25836,10 @@ impl AstNode for Rollback {
         &self.syntax
     }
 }
-impl AstNode for Row {
+impl AstNode for SetConfigParam {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ROW
+        kind == SyntaxKind::SET_CONFIG_PARAM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23272,10 +25854,10 @@ impl AstNode for Row {
         &self.syntax
     }
 }
-impl AstNode for RowList {
+impl AstNode for SetConstraints {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ROW_LIST
+        kind == SyntaxKind::SET_CONSTRAINTS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23290,10 +25872,10 @@ impl AstNode for RowList {
         &self.syntax
     }
 }
-impl AstNode for RowsFuncOption {
+impl AstNode for SetDefault {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::ROWS_FUNC_OPTION
+        kind == SyntaxKind::SET_DEFAULT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23308,10 +25890,10 @@ impl AstNode for RowsFuncOption {
         &self.syntax
     }
 }
-impl AstNode for Savepoint {
+impl AstNode for SetDefaultColumns {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SAVEPOINT
+        kind == SyntaxKind::SET_DEFAULT_COLUMNS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23326,10 +25908,10 @@ impl AstNode for Savepoint {
         &self.syntax
     }
 }
-impl AstNode for SchemaAuthorization {
+impl AstNode for SetExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SCHEMA_AUTHORIZATION
+        kind == SyntaxKind::SET_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23344,10 +25926,10 @@ impl AstNode for SchemaAuthorization {
         &self.syntax
     }
 }
-impl AstNode for SecurityFuncOption {
+impl AstNode for SetExprList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SECURITY_FUNC_OPTION
+        kind == SyntaxKind::SET_EXPR_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23362,10 +25944,10 @@ impl AstNode for SecurityFuncOption {
         &self.syntax
     }
 }
-impl AstNode for SecurityLabel {
+impl AstNode for SetExpression {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SECURITY_LABEL
+        kind == SyntaxKind::SET_EXPRESSION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23380,10 +25962,10 @@ impl AstNode for SecurityLabel {
         &self.syntax
     }
 }
-impl AstNode for Select {
+impl AstNode for SetFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SELECT
+        kind == SyntaxKind::SET_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23398,10 +25980,10 @@ impl AstNode for Select {
         &self.syntax
     }
 }
-impl AstNode for SelectClause {
+impl AstNode for SetGenerated {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SELECT_CLAUSE
+        kind == SyntaxKind::SET_GENERATED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23416,10 +25998,10 @@ impl AstNode for SelectClause {
         &self.syntax
     }
 }
-impl AstNode for SelectInto {
+impl AstNode for SetGeneratedOptions {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SELECT_INTO
+        kind == SyntaxKind::SET_GENERATED_OPTIONS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23434,10 +26016,10 @@ impl AstNode for SelectInto {
         &self.syntax
     }
 }
-impl AstNode for SequenceOption {
+impl AstNode for SetLogged {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SEQUENCE_OPTION
+        kind == SyntaxKind::SET_LOGGED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23452,10 +26034,10 @@ impl AstNode for SequenceOption {
         &self.syntax
     }
 }
-impl AstNode for SequenceOptionList {
+impl AstNode for SetMultipleColumns {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SEQUENCE_OPTION_LIST
+        kind == SyntaxKind::SET_MULTIPLE_COLUMNS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23470,10 +26052,10 @@ impl AstNode for SequenceOptionList {
         &self.syntax
     }
 }
-impl AstNode for Serializable {
+impl AstNode for SetNotNull {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SERIALIZABLE
+        kind == SyntaxKind::SET_NOT_NULL
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23488,10 +26070,10 @@ impl AstNode for Serializable {
         &self.syntax
     }
 }
-impl AstNode for Set {
+impl AstNode for SetNullColumns {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET
+        kind == SyntaxKind::SET_NULL_COLUMNS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23506,10 +26088,10 @@ impl AstNode for Set {
         &self.syntax
     }
 }
-impl AstNode for SetAccessMethod {
+impl AstNode for SetOptions {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_ACCESS_METHOD
+        kind == SyntaxKind::SET_OPTIONS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23524,10 +26106,10 @@ impl AstNode for SetAccessMethod {
         &self.syntax
     }
 }
-impl AstNode for SetClause {
+impl AstNode for SetOptionsList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_CLAUSE
+        kind == SyntaxKind::SET_OPTIONS_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23542,10 +26124,10 @@ impl AstNode for SetClause {
         &self.syntax
     }
 }
-impl AstNode for SetColumnList {
+impl AstNode for SetRole {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_COLUMN_LIST
+        kind == SyntaxKind::SET_ROLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23560,10 +26142,10 @@ impl AstNode for SetColumnList {
         &self.syntax
     }
 }
-impl AstNode for SetCompression {
+impl AstNode for SetSchema {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_COMPRESSION
+        kind == SyntaxKind::SET_SCHEMA
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23578,10 +26160,10 @@ impl AstNode for SetCompression {
         &self.syntax
     }
 }
-impl AstNode for SetConfigParam {
+impl AstNode for SetSequenceOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_CONFIG_PARAM
+        kind == SyntaxKind::SET_SEQUENCE_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23596,10 +26178,10 @@ impl AstNode for SetConfigParam {
         &self.syntax
     }
 }
-impl AstNode for SetConstraints {
+impl AstNode for SetSessionAuth {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_CONSTRAINTS
+        kind == SyntaxKind::SET_SESSION_AUTH
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23614,10 +26196,10 @@ impl AstNode for SetConstraints {
         &self.syntax
     }
 }
-impl AstNode for SetDefault {
+impl AstNode for SetSingleColumn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_DEFAULT
+        kind == SyntaxKind::SET_SINGLE_COLUMN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23632,10 +26214,10 @@ impl AstNode for SetDefault {
         &self.syntax
     }
 }
-impl AstNode for SetDefaultColumns {
+impl AstNode for SetStatistics {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_DEFAULT_COLUMNS
+        kind == SyntaxKind::SET_STATISTICS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23650,10 +26232,10 @@ impl AstNode for SetDefaultColumns {
         &self.syntax
     }
 }
-impl AstNode for SetExpr {
+impl AstNode for SetStorage {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_EXPR
+        kind == SyntaxKind::SET_STORAGE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23668,10 +26250,10 @@ impl AstNode for SetExpr {
         &self.syntax
     }
 }
-impl AstNode for SetExprList {
+impl AstNode for SetTablespace {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_EXPR_LIST
+        kind == SyntaxKind::SET_TABLESPACE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23686,10 +26268,10 @@ impl AstNode for SetExprList {
         &self.syntax
     }
 }
-impl AstNode for SetExpression {
+impl AstNode for SetTransaction {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_EXPRESSION
+        kind == SyntaxKind::SET_TRANSACTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23704,10 +26286,10 @@ impl AstNode for SetExpression {
         &self.syntax
     }
 }
-impl AstNode for SetFuncOption {
+impl AstNode for SetType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_FUNC_OPTION
+        kind == SyntaxKind::SET_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23722,10 +26304,10 @@ impl AstNode for SetFuncOption {
         &self.syntax
     }
 }
-impl AstNode for SetGenerated {
+impl AstNode for SetUnlogged {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_GENERATED
+        kind == SyntaxKind::SET_UNLOGGED
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23740,10 +26322,10 @@ impl AstNode for SetGenerated {
         &self.syntax
     }
 }
-impl AstNode for SetGeneratedOptions {
+impl AstNode for SetWithoutCluster {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_GENERATED_OPTIONS
+        kind == SyntaxKind::SET_WITHOUT_CLUSTER
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23758,10 +26340,10 @@ impl AstNode for SetGeneratedOptions {
         &self.syntax
     }
 }
-impl AstNode for SetLogged {
+impl AstNode for SetWithoutOids {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_LOGGED
+        kind == SyntaxKind::SET_WITHOUT_OIDS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23776,10 +26358,10 @@ impl AstNode for SetLogged {
         &self.syntax
     }
 }
-impl AstNode for SetMultipleColumns {
+impl AstNode for Show {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_MULTIPLE_COLUMNS
+        kind == SyntaxKind::SHOW
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23794,10 +26376,10 @@ impl AstNode for SetMultipleColumns {
         &self.syntax
     }
 }
-impl AstNode for SetNotNull {
+impl AstNode for SimilarTo {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_NOT_NULL
+        kind == SyntaxKind::SIMILAR_TO
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23812,10 +26394,10 @@ impl AstNode for SetNotNull {
         &self.syntax
     }
 }
-impl AstNode for SetNullColumns {
+impl AstNode for SliceExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_NULL_COLUMNS
+        kind == SyntaxKind::SLICE_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23830,10 +26412,10 @@ impl AstNode for SetNullColumns {
         &self.syntax
     }
 }
-impl AstNode for SetOptions {
+impl AstNode for SomeFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_OPTIONS
+        kind == SyntaxKind::SOME_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23848,10 +26430,10 @@ impl AstNode for SetOptions {
         &self.syntax
     }
 }
-impl AstNode for SetOptionsList {
+impl AstNode for SortAsc {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_OPTIONS_LIST
+        kind == SyntaxKind::SORT_ASC
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23866,10 +26448,10 @@ impl AstNode for SetOptionsList {
         &self.syntax
     }
 }
-impl AstNode for SetRole {
+impl AstNode for SortBy {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_ROLE
+        kind == SyntaxKind::SORT_BY
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23884,10 +26466,10 @@ impl AstNode for SetRole {
         &self.syntax
     }
 }
-impl AstNode for SetSchema {
+impl AstNode for SortByList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_SCHEMA
+        kind == SyntaxKind::SORT_BY_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23902,10 +26484,10 @@ impl AstNode for SetSchema {
         &self.syntax
     }
 }
-impl AstNode for SetSequenceOption {
+impl AstNode for SortDesc {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_SEQUENCE_OPTION
+        kind == SyntaxKind::SORT_DESC
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23920,10 +26502,10 @@ impl AstNode for SetSequenceOption {
         &self.syntax
     }
 }
-impl AstNode for SetSessionAuth {
+impl AstNode for SortUsing {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_SESSION_AUTH
+        kind == SyntaxKind::SORT_USING
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23938,10 +26520,10 @@ impl AstNode for SetSessionAuth {
         &self.syntax
     }
 }
-impl AstNode for SetSingleColumn {
+impl AstNode for SourceFile {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_SINGLE_COLUMN
+        kind == SyntaxKind::SOURCE_FILE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23956,10 +26538,10 @@ impl AstNode for SetSingleColumn {
         &self.syntax
     }
 }
-impl AstNode for SetStatistics {
+impl AstNode for Storage {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_STATISTICS
+        kind == SyntaxKind::STORAGE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23974,10 +26556,10 @@ impl AstNode for SetStatistics {
         &self.syntax
     }
 }
-impl AstNode for SetStorage {
+impl AstNode for StrictFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_STORAGE
+        kind == SyntaxKind::STRICT_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -23992,10 +26574,10 @@ impl AstNode for SetStorage {
         &self.syntax
     }
 }
-impl AstNode for SetTablespace {
+impl AstNode for SubstringFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_TABLESPACE
+        kind == SyntaxKind::SUBSTRING_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24010,10 +26592,10 @@ impl AstNode for SetTablespace {
         &self.syntax
     }
 }
-impl AstNode for SetTransaction {
+impl AstNode for SupportFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_TRANSACTION
+        kind == SyntaxKind::SUPPORT_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24028,10 +26610,10 @@ impl AstNode for SetTransaction {
         &self.syntax
     }
 }
-impl AstNode for SetType {
+impl AstNode for Table {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_TYPE
+        kind == SyntaxKind::TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24046,10 +26628,10 @@ impl AstNode for SetType {
         &self.syntax
     }
 }
-impl AstNode for SetUnlogged {
+impl AstNode for TableArgList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_UNLOGGED
+        kind == SyntaxKind::TABLE_ARG_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24064,10 +26646,10 @@ impl AstNode for SetUnlogged {
         &self.syntax
     }
 }
-impl AstNode for SetWithoutCluster {
+impl AstNode for TableList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_WITHOUT_CLUSTER
+        kind == SyntaxKind::TABLE_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24082,10 +26664,10 @@ impl AstNode for SetWithoutCluster {
         &self.syntax
     }
 }
-impl AstNode for SetWithoutOids {
+impl AstNode for TablesampleClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SET_WITHOUT_OIDS
+        kind == SyntaxKind::TABLESAMPLE_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24100,10 +26682,10 @@ impl AstNode for SetWithoutOids {
         &self.syntax
     }
 }
-impl AstNode for Show {
+impl AstNode for Tablespace {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SHOW
+        kind == SyntaxKind::TABLESPACE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24118,10 +26700,10 @@ impl AstNode for Show {
         &self.syntax
     }
 }
-impl AstNode for SimilarTo {
+impl AstNode for Target {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SIMILAR_TO
+        kind == SyntaxKind::TARGET
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24136,10 +26718,10 @@ impl AstNode for SimilarTo {
         &self.syntax
     }
 }
-impl AstNode for SliceExpr {
+impl AstNode for TargetList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SLICE_EXPR
+        kind == SyntaxKind::TARGET_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24154,10 +26736,10 @@ impl AstNode for SliceExpr {
         &self.syntax
     }
 }
-impl AstNode for SortAsc {
+impl AstNode for TimeType {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SORT_ASC
+        kind == SyntaxKind::TIME_TYPE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24172,10 +26754,10 @@ impl AstNode for SortAsc {
         &self.syntax
     }
 }
-impl AstNode for SortBy {
+impl AstNode for Timing {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SORT_BY
+        kind == SyntaxKind::TIMING
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24190,10 +26772,10 @@ impl AstNode for SortBy {
         &self.syntax
     }
 }
-impl AstNode for SortByList {
+impl AstNode for TransactionModeList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SORT_BY_LIST
+        kind == SyntaxKind::TRANSACTION_MODE_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24208,10 +26790,10 @@ impl AstNode for SortByList {
         &self.syntax
     }
 }
-impl AstNode for SortDesc {
+impl AstNode for TransformFromFunc {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SORT_DESC
+        kind == SyntaxKind::TRANSFORM_FROM_FUNC
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24226,10 +26808,10 @@ impl AstNode for SortDesc {
         &self.syntax
     }
 }
-impl AstNode for SortUsing {
+impl AstNode for TransformFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SORT_USING
+        kind == SyntaxKind::TRANSFORM_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24244,10 +26826,10 @@ impl AstNode for SortUsing {
         &self.syntax
     }
 }
-impl AstNode for SourceFile {
+impl AstNode for TransformToFunc {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SOURCE_FILE
+        kind == SyntaxKind::TRANSFORM_TO_FUNC
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24262,10 +26844,10 @@ impl AstNode for SourceFile {
         &self.syntax
     }
 }
-impl AstNode for Storage {
+impl AstNode for TriggerEvent {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::STORAGE
+        kind == SyntaxKind::TRIGGER_EVENT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24280,10 +26862,10 @@ impl AstNode for Storage {
         &self.syntax
     }
 }
-impl AstNode for StrictFuncOption {
+impl AstNode for TriggerEventList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::STRICT_FUNC_OPTION
+        kind == SyntaxKind::TRIGGER_EVENT_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24298,10 +26880,10 @@ impl AstNode for StrictFuncOption {
         &self.syntax
     }
 }
-impl AstNode for SupportFuncOption {
+impl AstNode for TriggerEventUpdate {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::SUPPORT_FUNC_OPTION
+        kind == SyntaxKind::TRIGGER_EVENT_UPDATE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24316,10 +26898,10 @@ impl AstNode for SupportFuncOption {
         &self.syntax
     }
 }
-impl AstNode for Table {
+impl AstNode for TrimFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TABLE
+        kind == SyntaxKind::TRIM_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24334,10 +26916,10 @@ impl AstNode for Table {
         &self.syntax
     }
 }
-impl AstNode for TableArgList {
+impl AstNode for Truncate {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TABLE_ARG_LIST
+        kind == SyntaxKind::TRUNCATE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24352,10 +26934,10 @@ impl AstNode for TableArgList {
         &self.syntax
     }
 }
-impl AstNode for TableList {
+impl AstNode for TupleExpr {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TABLE_LIST
+        kind == SyntaxKind::TUPLE_EXPR
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24370,10 +26952,10 @@ impl AstNode for TableList {
         &self.syntax
     }
 }
-impl AstNode for Tablespace {
+impl AstNode for UnicodeNormalForm {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TABLESPACE
+        kind == SyntaxKind::UNICODE_NORMAL_FORM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24388,10 +26970,10 @@ impl AstNode for Tablespace {
         &self.syntax
     }
 }
-impl AstNode for Target {
+impl AstNode for UniqueConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TARGET
+        kind == SyntaxKind::UNIQUE_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24406,10 +26988,10 @@ impl AstNode for Target {
         &self.syntax
     }
 }
-impl AstNode for TargetList {
+impl AstNode for Unlisten {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TARGET_LIST
+        kind == SyntaxKind::UNLISTEN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24424,10 +27006,10 @@ impl AstNode for TargetList {
         &self.syntax
     }
 }
-impl AstNode for TimeType {
+impl AstNode for Update {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TIME_TYPE
+        kind == SyntaxKind::UPDATE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24442,10 +27024,10 @@ impl AstNode for TimeType {
         &self.syntax
     }
 }
-impl AstNode for Timing {
+impl AstNode for UsingClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TIMING
+        kind == SyntaxKind::USING_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24460,10 +27042,10 @@ impl AstNode for Timing {
         &self.syntax
     }
 }
-impl AstNode for TransactionModeList {
+impl AstNode for UsingIndex {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TRANSACTION_MODE_LIST
+        kind == SyntaxKind::USING_INDEX
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24478,10 +27060,10 @@ impl AstNode for TransactionModeList {
         &self.syntax
     }
 }
-impl AstNode for TransformFromFunc {
+impl AstNode for UsingMethod {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TRANSFORM_FROM_FUNC
+        kind == SyntaxKind::USING_METHOD
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24496,10 +27078,10 @@ impl AstNode for TransformFromFunc {
         &self.syntax
     }
 }
-impl AstNode for TransformFuncOption {
+impl AstNode for UsingOnClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TRANSFORM_FUNC_OPTION
+        kind == SyntaxKind::USING_ON_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24514,10 +27096,10 @@ impl AstNode for TransformFuncOption {
         &self.syntax
     }
 }
-impl AstNode for TransformToFunc {
+impl AstNode for Vacuum {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TRANSFORM_TO_FUNC
+        kind == SyntaxKind::VACUUM
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24532,10 +27114,10 @@ impl AstNode for TransformToFunc {
         &self.syntax
     }
 }
-impl AstNode for TriggerEvent {
+impl AstNode for VacuumOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TRIGGER_EVENT
+        kind == SyntaxKind::VACUUM_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24550,10 +27132,10 @@ impl AstNode for TriggerEvent {
         &self.syntax
     }
 }
-impl AstNode for TriggerEventList {
+impl AstNode for VacuumOptionList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TRIGGER_EVENT_LIST
+        kind == SyntaxKind::VACUUM_OPTION_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24568,10 +27150,10 @@ impl AstNode for TriggerEventList {
         &self.syntax
     }
 }
-impl AstNode for TriggerEventUpdate {
+impl AstNode for ValidateConstraint {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TRIGGER_EVENT_UPDATE
+        kind == SyntaxKind::VALIDATE_CONSTRAINT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24586,10 +27168,10 @@ impl AstNode for TriggerEventUpdate {
         &self.syntax
     }
 }
-impl AstNode for Truncate {
+impl AstNode for Values {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TRUNCATE
+        kind == SyntaxKind::VALUES
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24604,10 +27186,10 @@ impl AstNode for Truncate {
         &self.syntax
     }
 }
-impl AstNode for TupleExpr {
+impl AstNode for Variant {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::TUPLE_EXPR
+        kind == SyntaxKind::VARIANT
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24622,10 +27204,10 @@ impl AstNode for TupleExpr {
         &self.syntax
     }
 }
-impl AstNode for UnicodeNormalForm {
+impl AstNode for VariantList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::UNICODE_NORMAL_FORM
+        kind == SyntaxKind::VARIANT_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24640,10 +27222,10 @@ impl AstNode for UnicodeNormalForm {
         &self.syntax
     }
 }
-impl AstNode for UniqueConstraint {
+impl AstNode for VolatilityFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::UNIQUE_CONSTRAINT
+        kind == SyntaxKind::VOLATILITY_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24658,10 +27240,10 @@ impl AstNode for UniqueConstraint {
         &self.syntax
     }
 }
-impl AstNode for Unlisten {
+impl AstNode for WhenClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::UNLISTEN
+        kind == SyntaxKind::WHEN_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24676,10 +27258,10 @@ impl AstNode for Unlisten {
         &self.syntax
     }
 }
-impl AstNode for Update {
+impl AstNode for WhenClauseList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::UPDATE
+        kind == SyntaxKind::WHEN_CLAUSE_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24694,10 +27276,10 @@ impl AstNode for Update {
         &self.syntax
     }
 }
-impl AstNode for UsingClause {
+impl AstNode for WhenCondition {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::USING_CLAUSE
+        kind == SyntaxKind::WHEN_CONDITION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24712,10 +27294,10 @@ impl AstNode for UsingClause {
         &self.syntax
     }
 }
-impl AstNode for UsingIndex {
+impl AstNode for WhereClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::USING_INDEX
+        kind == SyntaxKind::WHERE_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24730,10 +27312,10 @@ impl AstNode for UsingIndex {
         &self.syntax
     }
 }
-impl AstNode for UsingMethod {
+impl AstNode for WhereConditionClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::USING_METHOD
+        kind == SyntaxKind::WHERE_CONDITION_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24748,10 +27330,10 @@ impl AstNode for UsingMethod {
         &self.syntax
     }
 }
-impl AstNode for UsingOnClause {
+impl AstNode for WhereCurrentOf {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::USING_ON_CLAUSE
+        kind == SyntaxKind::WHERE_CURRENT_OF
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24766,10 +27348,10 @@ impl AstNode for UsingOnClause {
         &self.syntax
     }
 }
-impl AstNode for Vacuum {
+impl AstNode for WindowClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::VACUUM
+        kind == SyntaxKind::WINDOW_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24784,10 +27366,10 @@ impl AstNode for Vacuum {
         &self.syntax
     }
 }
-impl AstNode for VacuumOption {
+impl AstNode for WindowDef {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::VACUUM_OPTION
+        kind == SyntaxKind::WINDOW_DEF
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24802,10 +27384,10 @@ impl AstNode for VacuumOption {
         &self.syntax
     }
 }
-impl AstNode for VacuumOptionList {
+impl AstNode for WindowFuncOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::VACUUM_OPTION_LIST
+        kind == SyntaxKind::WINDOW_FUNC_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24820,10 +27402,10 @@ impl AstNode for VacuumOptionList {
         &self.syntax
     }
 }
-impl AstNode for ValidateConstraint {
+impl AstNode for WindowSpec {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::VALIDATE_CONSTRAINT
+        kind == SyntaxKind::WINDOW_SPEC
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24838,10 +27420,10 @@ impl AstNode for ValidateConstraint {
         &self.syntax
     }
 }
-impl AstNode for Values {
+impl AstNode for WithClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::VALUES
+        kind == SyntaxKind::WITH_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24856,10 +27438,10 @@ impl AstNode for Values {
         &self.syntax
     }
 }
-impl AstNode for Variant {
+impl AstNode for WithData {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::VARIANT
+        kind == SyntaxKind::WITH_DATA
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24874,10 +27456,10 @@ impl AstNode for Variant {
         &self.syntax
     }
 }
-impl AstNode for VariantList {
+impl AstNode for WithNoData {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::VARIANT_LIST
+        kind == SyntaxKind::WITH_NO_DATA
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24892,10 +27474,10 @@ impl AstNode for VariantList {
         &self.syntax
     }
 }
-impl AstNode for VolatilityFuncOption {
+impl AstNode for WithOptions {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::VOLATILITY_FUNC_OPTION
+        kind == SyntaxKind::WITH_OPTIONS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24910,10 +27492,10 @@ impl AstNode for VolatilityFuncOption {
         &self.syntax
     }
 }
-impl AstNode for WhenClause {
+impl AstNode for WithParams {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WHEN_CLAUSE
+        kind == SyntaxKind::WITH_PARAMS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24928,10 +27510,10 @@ impl AstNode for WhenClause {
         &self.syntax
     }
 }
-impl AstNode for WhenClauseList {
+impl AstNode for WithTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WHEN_CLAUSE_LIST
+        kind == SyntaxKind::WITH_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24946,10 +27528,10 @@ impl AstNode for WhenClauseList {
         &self.syntax
     }
 }
-impl AstNode for WhenCondition {
+impl AstNode for WithTimezone {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WHEN_CONDITION
+        kind == SyntaxKind::WITH_TIMEZONE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24964,10 +27546,10 @@ impl AstNode for WhenCondition {
         &self.syntax
     }
 }
-impl AstNode for WhereClause {
+impl AstNode for WithinClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WHERE_CLAUSE
+        kind == SyntaxKind::WITHIN_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -24982,10 +27564,10 @@ impl AstNode for WhereClause {
         &self.syntax
     }
 }
-impl AstNode for WhereCurrentOf {
+impl AstNode for WithoutOids {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WHERE_CURRENT_OF
+        kind == SyntaxKind::WITHOUT_OIDS
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25000,10 +27582,10 @@ impl AstNode for WhereCurrentOf {
         &self.syntax
     }
 }
-impl AstNode for WindowClause {
+impl AstNode for WithoutTimezone {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WINDOW_CLAUSE
+        kind == SyntaxKind::WITHOUT_TIMEZONE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25018,10 +27600,10 @@ impl AstNode for WindowClause {
         &self.syntax
     }
 }
-impl AstNode for WindowDef {
+impl AstNode for XmlAttributeList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WINDOW_DEF
+        kind == SyntaxKind::XML_ATTRIBUTE_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25036,10 +27618,10 @@ impl AstNode for WindowDef {
         &self.syntax
     }
 }
-impl AstNode for WindowFuncOption {
+impl AstNode for XmlColumnOption {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WINDOW_FUNC_OPTION
+        kind == SyntaxKind::XML_COLUMN_OPTION
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25054,10 +27636,10 @@ impl AstNode for WindowFuncOption {
         &self.syntax
     }
 }
-impl AstNode for WindowSpec {
+impl AstNode for XmlColumnOptionList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WINDOW_SPEC
+        kind == SyntaxKind::XML_COLUMN_OPTION_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25072,10 +27654,10 @@ impl AstNode for WindowSpec {
         &self.syntax
     }
 }
-impl AstNode for WithClause {
+impl AstNode for XmlElementFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WITH_CLAUSE
+        kind == SyntaxKind::XML_ELEMENT_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25090,10 +27672,10 @@ impl AstNode for WithClause {
         &self.syntax
     }
 }
-impl AstNode for WithData {
+impl AstNode for XmlExistsFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WITH_DATA
+        kind == SyntaxKind::XML_EXISTS_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25108,10 +27690,10 @@ impl AstNode for WithData {
         &self.syntax
     }
 }
-impl AstNode for WithNoData {
+impl AstNode for XmlForestFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WITH_NO_DATA
+        kind == SyntaxKind::XML_FOREST_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25126,10 +27708,10 @@ impl AstNode for WithNoData {
         &self.syntax
     }
 }
-impl AstNode for WithOptions {
+impl AstNode for XmlNamespace {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WITH_OPTIONS
+        kind == SyntaxKind::XML_NAMESPACE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25144,10 +27726,10 @@ impl AstNode for WithOptions {
         &self.syntax
     }
 }
-impl AstNode for WithParams {
+impl AstNode for XmlNamespaceList {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WITH_PARAMS
+        kind == SyntaxKind::XML_NAMESPACE_LIST
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25162,10 +27744,10 @@ impl AstNode for WithParams {
         &self.syntax
     }
 }
-impl AstNode for WithTable {
+impl AstNode for XmlParseFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WITH_TABLE
+        kind == SyntaxKind::XML_PARSE_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25180,10 +27762,10 @@ impl AstNode for WithTable {
         &self.syntax
     }
 }
-impl AstNode for WithTimezone {
+impl AstNode for XmlPassingMech {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WITH_TIMEZONE
+        kind == SyntaxKind::XML_PASSING_MECH
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25198,10 +27780,10 @@ impl AstNode for WithTimezone {
         &self.syntax
     }
 }
-impl AstNode for WithinClause {
+impl AstNode for XmlPiFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WITHIN_CLAUSE
+        kind == SyntaxKind::XML_PI_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25216,10 +27798,10 @@ impl AstNode for WithinClause {
         &self.syntax
     }
 }
-impl AstNode for WithoutOids {
+impl AstNode for XmlRootFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WITHOUT_OIDS
+        kind == SyntaxKind::XML_ROOT_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25234,10 +27816,10 @@ impl AstNode for WithoutOids {
         &self.syntax
     }
 }
-impl AstNode for WithoutTimezone {
+impl AstNode for XmlRowPassingClause {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::WITHOUT_TIMEZONE
+        kind == SyntaxKind::XML_ROW_PASSING_CLAUSE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25252,10 +27834,10 @@ impl AstNode for WithoutTimezone {
         &self.syntax
     }
 }
-impl AstNode for XmlColumnOption {
+impl AstNode for XmlSerializeFn {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::XML_COLUMN_OPTION
+        kind == SyntaxKind::XML_SERIALIZE_FN
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -25270,10 +27852,10 @@ impl AstNode for XmlColumnOption {
         &self.syntax
     }
 }
-impl AstNode for XmlColumnOptionList {
+impl AstNode for XmlTable {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SyntaxKind::XML_COLUMN_OPTION_LIST
+        kind == SyntaxKind::XML_TABLE
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
diff --git a/crates/squawk_syntax/src/postgresql.ungram b/crates/squawk_syntax/src/postgresql.ungram
index 71569f25..28aace36 100644
--- a/crates/squawk_syntax/src/postgresql.ungram
+++ b/crates/squawk_syntax/src/postgresql.ungram
@@ -17,7 +17,6 @@
 NameRef =
   '#ident'?
 
-
 Name =
   '#ident'?
 
@@ -43,9 +42,6 @@ ParamIn =
 ParamOut =
   'out'
 
-Arg =
-  Expr
-
 ParamMode =
   ParamVariadic
 | ParamInOut
@@ -68,11 +64,275 @@ ArgList =
 
 CallExpr =
   Expr ArgList WithinClause? FilterClause? OverClause?
+| ExtractFn
+| JsonExistsFn
+| JsonArrayFn
+| JsonObjectFn
+| JsonObjectAggFn WithinClause? FilterClause? OverClause?
+| JsonArrayAggFn WithinClause? FilterClause? OverClause?
+| JsonQueryFn
+| JsonScalarFn
+| JsonSerializeFn
+| JsonValueFn
+| JsonFn
+| SubstringFn
+| PositionFn
+| OverlayFn
+| TrimFn
+| XmlRootFn
+| XmlSerializeFn
+| XmlElementFn
+| XmlForestFn
+| XmlExistsFn
+| XmlParseFn
+| XmlPiFn
+| SomeFn
+| AnyFn
+| AllFn
+| ExistsFn
+
+JsonArrayFn =
+ 'json_array' '(' 
+  (
+     (JsonSelectFormat (',' JsonSelectFormat)*) JsonNullClause?
+   | (JsonExprFormat (',' JsonExprFormat)*)
+  )
+  JsonReturningClause?
+ ')'
+
+JsonScalarFn =
+  'json_scalar' '(' Expr ')'
+
+JsonFn =
+  'json' '(' JsonExprFormat JsonKeysUniqueClause? ')'
+
+JsonSelectFormat =
+  SelectVariant JsonFormatClause?
+
+JsonExprFormat =
+  Expr JsonFormatClause?
+
+JsonEncodingClause =
+  'encoding' NameRef
+
+SomeFn = 
+  'some' '(' SelectVariant | Expr ')'
+
+AnyFn = 
+  'any' '(' SelectVariant | Expr ')'
+
+AllFn =
+  'all' '(' SelectVariant | Expr ')'
+
+ExtractFn =
+  'extract' '(' 
+    ('#ident' | 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | '@string')
+    'from'
+    Expr
+  ')'
+
+JsonExistsFn =
+  'json_exists' '('
+    Expr
+    JsonFormatClause?
+    ','
+    Expr
+    JsonPassingClause?
+    JsonOnErrorClause?
+  ')'
+
+JsonObjectFn =
+  'json_object' '('
+    (JsonReturningClause
+    | (JsonKeyValue (',' JsonKeyValue)*) 
+      JsonNullClause?
+      JsonKeysUniqueClause?
+      JsonReturningClause?
+    )
+  
+  ')'
+
+JsonObjectAggFn =
+  'json_objectagg' '('
+    JsonKeyValue?
+    JsonNullClause?
+    JsonKeysUniqueClause?
+    ReturningClause?
+  ')'
+
+JsonArrayAggFn =
+  'json_arrayagg' '('
+    (JsonSelectFormat (',' JsonSelectFormat)*)
+      JsonNullClause?
+      JsonReturningClause?
+    | Expr JsonReturningClause
+  ')'
+
+JsonQueryFn =
+  'json_query' '('
+    Expr
+    JsonFormatClause
+    ','
+    Expr
+    JsonPassingClause?
+    JsonReturningClause?
+    JsonWrapperBehaviorClause?
+    JsonQuotesClause?
+    JsonBehaviorClause?
+  ')'
+
+XmlTable =
+   'xmltable'
+   '(' 
+     ('xmlnamespaces' XmlNamespaceList ',')
+     XmlRowPassingClause
+     XmlTableColumnList
+   ')'
+
+XmlRowPassingClause =
+  Expr 'passing' XmlPassingMech? Expr XmlPassingMech?
+
+XmlNamespaceList = 
+  '(' (XmlNamespace (',' XmlNamespace )*) ')'
+
+XmlNamespace =
+  'default' Expr
+| Expr 'as' Name
+
+XmlPassingMech =
+  'by' 'ref'
+| 'by' 'value'
+
+JsonTable =
+  'json_table' '(' 
+    Expr
+    JsonFormatClause?
+    ','
+    Expr
+    ('as' Name)?
+    JsonPassingClause
+    JsonTableColumnList
+    JsonOnErrorClause
+  ')'
+
+JsonSerializeFn =
+  'json_serialize' '('
+    Expr
+    JsonFormatClause?
+    JsonReturningClause?
+  ')'
+
+JsonValueFn =
+  'json_value' '('
+    Expr
+    JsonFormatClause?
+    ','
+    Expr
+    JsonPassingClause?
+    JsonReturningClause?
+    JsonBehaviorClause?
+  ')'
+
+SubstringFn =
+  'substring' '('
+    Expr 'for' Expr ('from' Expr)
+  | Expr 'from' Expr ('for' Expr)
+  | Expr 'similar' Expr
+  | (Expr (',' Expr)*)
+  ')'
+
+PositionFn =
+  'position' '(' Expr 'in' Expr ')'
+
+OverlayFn =
+  'overlay' '('
+    (
+      Expr 'placing' Expr 'from' Expr ('for' Expr)?
+    | (Expr (',' Expr)*)?
+    )
+  ')'
+
+TrimFn =
+  'trim' '('
+    'from' (Expr (',' Expr)*)
+   | Expr 'from' Expr
+   | (Expr (',' Expr)*)?
+  ')'
+
+XmlRootFn =
+  'xmlroot' '('
+    Expr ',' 
+    ('version' 'no' 'value' | 'version' Expr)
+    (
+      ',' 'standalone' 'yes'
+    | ',' 'standalone' 'no'
+    | ',' 'standalone' 'no' 'value'
+    )?
+  ')'
+
+XmlSerializeFn =
+  'xmlserialize' '('
+    ('document' | 'content')
+    Expr
+    'as'
+    Type
+    ('no' 'ident' | 'ident')?
+  ')'
+
+XmlElementFn =
+  'xmlelement' '('
+    'name'
+    Name
+    ( 
+      ',' 'xmlattributes' '(' 
+           XmlAttributeList
+        ')'
+        (',' (Expr (',' Expr)*))?
+    | ',' (Expr (',' Expr)*)
+    )
+  ')'
+
+ExprAsName =
+  Expr AsName?
+
+XmlAttributeList =
+  (ExprAsName (',' ExprAsName)*)
+
+XmlForestFn =
+  'xmlforest' '(' XmlAttributeList ')'
+
+XmlExistsFn =
+  'xmlexists' '('
+    'passing'
+    XmlPassingMech?
+    Expr
+    XmlPassingMech?
+  ')'
+
+XmlParseFn =
+  'xmlparse' '('
+    ('document' | 'content')
+    Expr
+    (
+      'preserve' 'whitespace'
+    | 'strip' 'whitespace'
+    )
+  ')'
+
+XmlPiFn =
+  'xmlpi' '('
+    'name'
+    Name
+    (',' Expr)?
+  ')'
+
+ExistsFn =
+  'exists' '(' SelectVariant ')'
 
 CastExpr =
-  'cast' '(' Expr 'as' Type ')'
+  ('cast' | 'treat') '(' Expr 'as' Type ')'
 | Expr ColonColon Type
-| Expr Type
+| Type Literal
 
 ArrayExpr =
   'array' '[' (Expr (',' Expr)*) ']'
@@ -95,7 +355,7 @@ NamedArg =
   NameRef FatArrow Expr
 
 JsonFormatClause =
-  'format' 'json' ('encoding' Name)?
+  'format' 'json' JsonEncodingClause?
 
 JsonValueExpr =
   Expr JsonFormatClause?
@@ -122,7 +382,7 @@ NotIlike =
   'not' 'ilike'
 
 CustomOp =
-  ('+' | '-' | '*' | '/' | '<' | '>' | '=' | '~' | '!' | '@' | '#' | '%' | '^' | '&' | '|' | '`' | '?')
+  '+' | '-' | '*' | '/' | '<' | '>' | '=' | '~' | '!' | '@' | '#' | '%' | '^' | '&' | '|' | '`' | '?'
 
 NotIn =
  'not' 'in'
@@ -296,6 +556,9 @@ Type =
 | TimeType
 | IntervalType
 
+Arg =
+  Expr
+
 // For when we're parsing expressions and then later we realize they're types.
 // e.g., `select pg_catalog.varchar(10) 'foo'`
 ExprType =
@@ -452,22 +715,6 @@ DefaultConstraint =
   ('constraint' NameRef)
   'default' Expr
 
-// SequenceOption =
-//   'as' Type
-// | 'increment' 'by'? Literal
-// | 'sequence' 'name' NameRef
-// | 'restart' ('with'? Literal)?
-// | 'logged'
-// | 'unlogged'
-// | 'start' 'with'? Literal
-// | 'owned' 'by' ('none' | Path)
-// | 'maxvalue' Literal
-// | 'minvalue' Literal
-// | 'no' 'minvalue'
-// | 'no' 'cycle'
-// | 'no' 'maxvalue'
-// | 'cycle'
-
 GeneratedConstraint =
   ('constraint' NameRef)
   'generated'
@@ -656,8 +903,20 @@ SequenceOptionList =
   '(' (SequenceOption (',' SequenceOption)*) ')'
 
 SequenceOption =
-  'cycle'
-| 'no' ('minvalue' | 'cycle' | 'maxvalue')
+  'as' Type
+| 'increment' 'by'? Literal
+| 'sequence' 'name' NameRef
+| 'restart' ('with'? Literal)?
+| 'logged'
+| 'unlogged'
+| 'start' 'with'? Literal
+| 'owned' 'by' ('none' | Path)
+| 'maxvalue' Literal
+| 'minvalue' Literal
+| 'no' 'maxvalue'
+| 'no' 'minvalue'
+| 'no' 'cycle'
+| 'cycle'
 
 ColumnList =
   '(' (Column (',' Column)*) ')'
@@ -666,7 +925,7 @@ ConstraintIncludeClause =
   'include'
 
 WithParams =
-  'with' '(' ')'
+  'with' AttributeList
 
 ConstraintIndexTablespace =
   'using' 'index' 'tablespace' NameRef
@@ -836,7 +1095,18 @@ PartitionBy =
   ) PartitionItemList
 
 CreateTable =
-  'create' 'table' IfNotExists? Path PartitionOf? OfType? TableArgList Inherits? PartitionBy? UsingMethod? (WithParams | WithoutOids)? OnCommit? Tablespace?
+  'create' 
+  (('global' | 'local')? ('temporary' | 'temp' | 'unlogged' ))?
+  'table' IfNotExists? Path 
+  PartitionOf?
+  OfType?
+  TableArgList
+  Inherits?
+  PartitionBy?
+  UsingMethod?
+  (WithParams | WithoutOids)?
+  OnCommit?
+  Tablespace?
 
 CreateIndex =
   'create' 'unique'? 'index' 'concurrently'? (IfNotExists? Name)? 'on' RelationName 
@@ -1140,7 +1410,18 @@ WithNoData =
   'with' 'no' 'data'
 
 CreateTableAs =
-  'create' 'table' IfNotExists? Path UsingMethod? WithParams? OnCommit? Tablespace? 'as' query:SelectVariant (WithData | WithNoData)?
+  'create'
+  (('global' | 'local')? ('temporary' | 'temp' | 'unlogged' ))?
+  'table'
+  IfNotExists?
+  Path
+  UsingMethod?
+  (WithParams | WithoutOids)?
+  OnCommit?
+  Tablespace?
+  'as'
+  query:SelectVariant
+  (WithData | WithNoData)?
 
 CreateMaterializedView =
   'create' 'materialized' 'view' IfNotExists? Path ColumnList? 
@@ -1187,7 +1468,19 @@ BetweenExpr =
 JsonTableColumn =
   Name 'for' 'ordinality'
 | Name Type
-| 'nested' 'path'? Expr
+    JsonFormatClause?
+    JsonPathClause?
+    JsonWrapperBehaviorClause?
+    JsonQuotesClause?
+    (JsonOnErrorClause | JsonOnEmptyClause)?
+| Name Type
+    'exists'
+    JsonPathClause?
+    JsonOnErrorClause?
+| 'nested' 'path'? Expr ('as' Name)? JsonTableColumnList
+
+JsonPathClause =
+  'path' Expr
 
 JsonTableColumnList =
   'columns' '(' (JsonTableColumn (',' JsonTableColumn)*) ')'
@@ -1239,7 +1532,9 @@ JsonBehavior =
 | JsonBehaviorEmptyObject
 
 JsonWrapperBehaviorClause =
-  'with' 'wrapper' | 'without' 'wrapper' | 'with' 'conditional' 'wrapper'
+  'without' 'array'? 'wrapper'
+| 'with' 'unconditional'? 'array'? 'wrapper'
+| 'with' 'conditional' 'array'? 'wrapper'
 
 JsonOnErrorClause =
   JsonBehavior 'on' 'error'
@@ -1247,8 +1542,11 @@ JsonOnErrorClause =
 JsonOnEmptyClause =
   JsonBehavior 'on' 'empty'
 
+JsonBehaviorClause =
+  JsonBehavior
+
 JsonPassingArg =
-  Expr JsonFormatClause? 'as' Name
+  Expr
 
 JsonPassingClause =
   'passing' (JsonPassingArg (',' JsonPassingArg)*)
@@ -1371,11 +1669,20 @@ OrderByClause =
 SortByList =
   SortBy (',' SortBy)*
 
+RepeatableClause =
+  'repeatable' '(' Expr ')'
+
+TablesampleClause =
+  'tablesample' CallExpr RepeatableClause?
+
 FromItem =
-  'only'? (NameRef | FieldExpr) Alias?
+  'only'? (NameRef | FieldExpr) Alias? TablesampleClause?
 | 'lateral'? ParenSelect Alias?
-| 'lateral'? CallExpr Alias?
-| 'lateral'? 'rows' 'from' '(' CallExpr ')' Alias?
+| 'lateral'? CallExpr ('with' 'ordinality')? Alias?
+| 'lateral'? JsonTable Alias?
+| 'lateral'? XmlTable Alias?
+| 'lateral'? CastExpr Alias?
+| 'lateral'? 'rows' 'from' '(' CallExpr ')' ('with' 'ordinality')? Alias?
 
 FromClause =
   'from'
@@ -1406,15 +1713,15 @@ ConstraintExclusionList =
   '(' (ConstraintExclusion (',' ConstraintExclusion)*) ')'
 
 ConstraintExclusion = 
- Expr 'with'
+ Expr 'with' Op
 
-ConstraintWhereClause =
+WhereConditionClause =
   'where' '(' Expr ')'
 
 ExcludeConstraint =
   ('constraint' Name)
   'exclude' ConstraintIndexMethod? ConstraintExclusionList
-  ConstraintWhereClause?
+  WhereConditionClause?
 
 FrameClause =
   'range' | 'rows' | 'groups'
@@ -1823,9 +2130,17 @@ EventTriggerWhen =
 
 CreateForeignDataWrapper =
   'create' 'foreign' 'data' 'wrapper' Name
+  FdwOptionList?
+  AlterOptionList?
 
 CreateForeignTable =
-  'create' 'foreign' 'table' IfNotExists? Path TableArgList? ('server' NameRef)?
+  'create' 'foreign' 'table' IfNotExists? Path
+  PartitionOf?
+  TableArgList?
+  Inherits?
+  PartitionType?
+  ('server' NameRef)
+  AlterOptionList?
 
 CreateGroup =
   'create' 'group' Name RoleOptionList
@@ -1837,7 +2152,8 @@ RoleOption =
   'inherit'
 
 CreateLanguage =
-  'create' 'language' Name
+  'create' OrReplace 'trusted'? 'procedural'? 'language' Name
+  ('handler' Path ('inline' Path)? ('validator' Path)?)?
 
 CreateOperator =
   'create' 'operator' 
@@ -1859,15 +2175,27 @@ CreateOperatorFamily =
 
 CreatePolicy =
   'create' 'policy' Name OnTable
+  ('as' '#ident')?
+  ('for' ('all' | 'select' | 'insert' | 'update' | 'delete'))?
+  ('to' RoleList)?
+  ('using' '(' Expr ')')
+  ('with' 'check' '(' Expr ')')
 
 CreateProcedure =
-  'create' 'procedure' Path ParamList option_list:FuncOptionList
+  'create' OrReplace? 'procedure' Path ParamList option_list:FuncOptionList
 
 CreatePublication =
   'create' 'publication' Name
+  ('for' 'all' 'tables' | 'for' (PublicationObject (',' PublicationObject)*))
+  WithParams?
+
+PublicationObject  =
+  'table' 'only'? (Path | '(' Path ')') '*'? ColumnList?  WhereConditionClause?
+| 'tables' 'in' 'schema' ('current_schema' | NameRef) WhereConditionClause?
+| 'current_schema'
 
 CreateRole =
-  'create' 'role' Name
+  'create' 'role' Name RoleOptionList
 
 CreateRule =
   'create' OrReplace? 'rule' Name 'as' 'on' ('#ident' | 'select' | 'insert' | 'update' | 'delete')
@@ -1879,13 +2207,21 @@ CreateSequence =
   SequenceOption*
 
 CreateServer =
-  'create' 'server' Name
+  'create' 'server' IfNotExists? Name
+  ('type' Literal)?
+  ('version' Literal)?
+  'foreign' 'data' 'wrapper' NameRef
+  AlterOptionList?
+
 
 CreateStatistics =
   'create' 'statistics' Path ('on' (NameRef (',' NameRef)*))? FromTable?
 
 CreateSubscription =
   'create' 'subscription' Name
+  'connection' Literal
+  'publication' (NameRef (',' NameRef)*)
+  WithParams?
 
 CreateTablespace =
   'create' 'tablespace' Name
@@ -1916,19 +2252,24 @@ TransformToFunc =
   'to' 'sql' 'with' 'function' FunctionSig
 
 CreateUserMapping =
-  'create' 'user' 'mapping' 'for' Role 'server' NameRef AlterOptionList?
+  'create' 'user' 'mapping' IfNotExists? 'for' Role
+  'server' NameRef
+  AlterOptionList?
 
 CreateUser =
   'create' 'user' Name
+  RoleOptionList?
 
 DropLanguage =
-  'drop' 'language' IfExists? NameRef
+  'drop' 'procedural'? 'language' IfExists? NameRef
+  ('cascade' | 'restrict')?
 
 DropGroup =
   'drop' 'group' IfExists? (NameRef (',' NameRef)*)
 
 DropFunction =
   'drop' 'function' IfExists? FunctionSigList
+  ('cascade' | 'restrict')?
 
 FunctionSigList =
   (FunctionSig (',' FunctionSig)*)
@@ -1937,10 +2278,12 @@ FunctionSig =
   Path ParamList?
 
 DropForeignDataWrapper =
-  'drop' 'foreign' 'data' 'wrapper' IfExists? NameRef
+  'drop' 'foreign' 'data' 'wrapper' IfExists? (NameRef (',' NameRef)*)
+  ('cascade' | 'restrict')
 
 DropForeignTable =
   'drop' 'foreign' 'table' IfExists? Path
+  ('cascade' | 'restrict')
 
 DropAccessMethod =
   'drop' 'access' 'method' IfExists? NameRef
@@ -1994,7 +2337,7 @@ DropOperatorClass =
   'drop' 'operator' 'class' IfExists? Path 'using' NameRef
 
 DropOwned =
-  'drop' 'owned' 'by'
+  'drop' 'owned' 'by' RoleList ('cascade' | 'restrict')?
 
 DropPolicy =
   'drop' 'policy' IfExists? NameRef OnTable
@@ -2179,7 +2522,7 @@ Reindex =
   'reindex' ('table' | 'index' | 'schema' | 'database' | 'system')? Path?
 
 CreateView =
-  'create' OrReplace? 'recursive'? 'view' Path ColumnList?
+  'create' OrReplace? ('temp' | 'temporary')? 'recursive'? 'view' Path ColumnList?
   WithParams?
   'as' query:SelectVariant
   ('with' ('cascaded' | 'local') 'check' 'option')
diff --git a/crates/xtask/src/codegen.rs b/crates/xtask/src/codegen.rs
index 8e3e7588..ce9111ba 100644
--- a/crates/xtask/src/codegen.rs
+++ b/crates/xtask/src/codegen.rs
@@ -628,6 +628,9 @@ fn lower_rule(acc: &mut Vec<Field>, grammar: &Grammar, label: Option<&String>, r
                 | "base" | "index"
                 // field expr fields
                 | /* "base" | */ "field"
+                | /* case expr  */ "condition" | "then"
+                | /* add foreign key constraint */ "from_columns" | "to_columns"
+                | /* rename column */ "from" | "to"
             );
             if manually_implemented {
                 return;