From 134a9221e06507734b291db19d4701b6ae8f4168 Mon Sep 17 00:00:00 2001 From: Steve Dignam Date: Thu, 4 Dec 2025 20:11:04 -0500 Subject: [PATCH 1/2] parser: update with proper nodes for special cased functions previously we weren't exposing special functions like any, some, all, extract, substring, etc. now they're in the ast also improved the structure for a handful of these functions --- PLAN.md | 49 + crates/squawk_ide/src/expand_selection.rs | 2 + .../src/generated/syntax_kind.rs | 43 +- crates/squawk_parser/src/grammar.rs | 818 +- crates/squawk_parser/tests/data/ok/select.sql | 5 + .../tests/data/ok/select_xml.sql | 34 + .../tests__alter_publication_ok.snap | 374 +- .../snapshots/tests__alter_table_ok.snap | 2 +- .../tests__create_publication_ok.snap | 224 +- .../snapshots/tests__create_table_ok.snap | 11 +- .../tests/snapshots/tests__misc_ok.snap | 6 +- .../snapshots/tests__regression_sqljson.snap | 208 +- .../snapshots/tests__select_funcs_ok.snap | 464 +- .../tests__select_funcs_pg17_ok.snap | 808 +- .../tests/snapshots/tests__select_ok.snap | 456 +- .../tests/snapshots/tests__select_xml_ok.snap | 203 + .../squawk_syntax/src/ast/generated/nodes.rs | 11977 ++++++++++------ crates/squawk_syntax/src/postgresql.ungram | 435 +- 18 files changed, 9830 insertions(+), 6289 deletions(-) create mode 100644 crates/squawk_parser/tests/data/ok/select_xml.sql create mode 100644 crates/squawk_parser/tests/snapshots/tests__select_xml_ok.snap 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(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..eca0a22b 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,31 @@ 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_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 +954,7 @@ pub enum SyntaxKind { OP_SIG_LIST, ORDER_BY_CLAUSE, OR_REPLACE, + OVERLAY_FN, OVER_CLAUSE, OWNER_TO, PARALLEL_FUNC_OPTION, @@ -960,6 +980,7 @@ pub enum SyntaxKind { PATH_TYPE, PERCENT_TYPE, PERCENT_TYPE_CLAUSE, + POSITION_FN, POSTFIX_EXPR, PREFIX_EXPR, PREPARE, @@ -968,6 +989,7 @@ pub enum SyntaxKind { PRIMARY_KEY_CONSTRAINT, PRIVILEGES, PRIVILEGE_TARGET, + PUBLICATION_OBJECT, READ_COMMITTED, READ_ONLY, READ_UNCOMMITTED, @@ -985,6 +1007,7 @@ pub enum SyntaxKind { RENAME_COLUMN, RENAME_CONSTRAINT, RENAME_TO, + REPEATABLE_CLAUSE, REPEATABLE_READ, REPLICA_IDENTITY, RESET, @@ -1058,6 +1081,7 @@ pub enum SyntaxKind { SHOW, SIMILAR_TO, SLICE_EXPR, + SOME_FN, SORT_ASC, SORT_BY, SORT_BY_LIST, @@ -1066,8 +1090,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 +1108,7 @@ pub enum SyntaxKind { TRIGGER_EVENT, TRIGGER_EVENT_LIST, TRIGGER_EVENT_UPDATE, + TRIM_FN, TRUNCATE, TUPLE_EXPR, UNICODE_NORMAL_FORM, @@ -1104,6 +1131,7 @@ pub enum SyntaxKind { WHEN_CLAUSE_LIST, WHEN_CONDITION, WHERE_CLAUSE, + WHERE_CONDITION_CLAUSE, WHERE_CURRENT_OF, WINDOW_CLAUSE, WINDOW_DEF, @@ -1119,8 +1147,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..63bea710 100644 --- a/crates/squawk_parser/src/grammar.rs +++ b/crates/squawk_parser/src/grammar.rs @@ -247,13 +247,16 @@ 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); + m.complete(p, EXTRACT_FN).precede(p).complete(p, CALL_EXPR) } // | OVERLAY '(' overlay_list ')' @@ -263,10 +266,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 +285,11 @@ 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); + m.complete(p, OVERLAY_FN).precede(p).complete(p, CALL_EXPR) } // POSITION '(' position_list ')' @@ -305,41 +310,47 @@ 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); + m.complete(p, POSITION_FN).precede(p).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); + m.complete(p, TRIM_FN).precede(p).complete(p, CALL_EXPR) } // SUBSTRING '(' substr_list ')' @@ -353,48 +364,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); + m.complete(p, SUBSTRING_FN) + .precede(p) + .complete(p, CALL_EXPR) } fn opt_json_encoding_clause(p: &mut Parser<'_>) { @@ -469,6 +485,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 +531,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 +556,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); + m.complete(p, JSON_OBJECT_FN) + .precede(p) + .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); + m.complete(p, JSON_OBJECT_AGG_FN) + .precede(p) + .complete(p, CALL_EXPR) } /// 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 +677,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 +693,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 +714,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 +736,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); + m.complete(p, JSON_ARRAY_FN) + .precede(p) + .complete(p, CALL_EXPR) } /// @@ -743,10 +757,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,7 +775,7 @@ fn some_any_all_fn(p: &mut Parser<'_>) -> CompletedMarker { } } p.expect(R_PAREN); - m.complete(p, CALL_EXPR) + m.complete(p, kind).precede(p).complete(p, CALL_EXPR) } // literal, path, tuple, array @@ -829,39 +847,50 @@ fn atom_expr(p: &mut Parser<'_>) -> Option { 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); + m.complete(p, JSON_ARRAY_AGG_FN) + .precede(p) + .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); + m.complete(p, EXISTS_FN).precede(p).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); + m.complete(p, XML_PI_FN).precede(p).complete(p, CALL_EXPR) } // XMLPARSE '(' document_or_content a_expr xml_whitespace_option ')' @@ -874,41 +903,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); + m.complete(p, XML_PARSE_FN) + .precede(p) + .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 +948,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); + m.complete(p, XML_EXISTS_FN) + .precede(p) + .complete(p, CALL_EXPR) } // XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ',' expr_list ')' @@ -942,46 +972,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); + m.complete(p, XML_ELEMENT_FN) + .precede(p) + .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); + m.complete(p, XML_FOREST_FN) + .precede(p) + .complete(p, CALL_EXPR) } // XMLSERIALIZE '(' document_or_content a_expr AS SimpleTypename xml_indent_option ')' @@ -991,23 +1035,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); + m.complete(p, XML_SERIALIZE_FN) + .precede(p) + .complete(p, CALL_EXPR) } // XMLROOT '(' a_expr ',' xml_root_version opt_xml_root_standalone ')' @@ -1021,39 +1070,45 @@ 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); + m.complete(p, XML_ROOT_FN).precede(p).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 + if expr(p).is_none() { + p.error("expected expression"); + } + opt_json_format_clause(p); + opt_json_keys_unique_clause(p); + p.expect(R_PAREN); + m.complete(p, JSON_FN).precede(p).complete(p, CALL_EXPR) } // JSON_VALUE '(' @@ -1063,32 +1118,42 @@ 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); + m.complete(p, JSON_VALUE_FN) + .precede(p) + .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); + if expr(p).is_none() { + p.error("expected expression"); + } + opt_json_format_clause(p); + opt_json_returning_clause(p); + p.expect(R_PAREN); + m.complete(p, JSON_SERIALIZE_FN) + .precede(p) + .complete(p, CALL_EXPR) } // JSON_QUERY ( @@ -1102,23 +1167,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); + m.complete(p, JSON_QUERY_FN) + .precede(p) + .complete(p, CALL_EXPR) } fn opt_json_quotes_clause(p: &mut Parser<'_>) -> Option { @@ -1195,18 +1265,23 @@ fn opt_json_wrapper_behavior(p: &mut Parser<'_>) -> Option { // ) 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); + m.complete(p, JSON_EXISTS_FN) + .precede(p) + .complete(p, CALL_EXPR) } fn opt_json_on_error_clause(p: &mut Parser<'_>) { @@ -2260,7 +2335,7 @@ fn bexpr(p: &mut Parser<'_>) -> Option { ) } -fn json_object_arg(p: &mut Parser) -> Option { +fn json_key_value(p: &mut Parser) -> Option { let m = p.start(); if expr(p).is_none() { p.error("expected expression"); @@ -2482,7 +2557,7 @@ fn expr_bp(p: &mut Parser<'_>, bp: u8, r: &Restrictions) -> Option 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 +2819,7 @@ fn opt_locking_clause(p: &mut Parser<'_>) -> Option { } lock_strength(p); if p.eat(OF_KW) { - if !expr_list(p) { + if !opt_expr_list(p) { p.error("expected an expression"); } } @@ -3065,17 +3140,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 +3163,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 +3198,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 +3292,26 @@ fn opt_xmltable_column_option_el(p: &mut Parser<'_>) -> Option } 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 +3323,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 { @@ -4118,7 +4213,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 +4479,33 @@ fn opt_alias(p: &mut Parser<'_>) -> Option { Some(m.complete(p, ALIAS)) } +// [ TABLESAMPLE sampling_method ( argument [, ...] ) [ REPEATABLE ( seed ) ] ] +fn opt_tablesample_clause(p: &mut Parser<'_>) -> Option { + 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 { + 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 { if !p.at(WHERE_KW) { return None; @@ -4555,7 +4677,7 @@ fn window_spec(p: &mut Parser<'_>) -> Option { 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 +9108,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 +9129,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 +9315,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 ' + + the great gatsby + f. scott fitzgerald + 1925 + 12.99 + + + 1984 + george orwell + 1949 + 14.99 + + + to kill a mockingbird + harper lee + 1960 + 13.99 + + ') + 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__regression_sqljson.snap b/crates/squawk_parser/tests/snapshots/tests__regression_sqljson.snap index 7c4c9dd3..d68e7493 100644 --- a/crates/squawk_parser/tests/snapshots/tests__regression_sqljson.snap +++ b/crates/squawk_parser/tests/snapshots/tests__regression_sqljson.snap @@ -2,4 +2,210 @@ source: crates/squawk_parser/tests/tests.rs input_file: crates/squawk_parser/tests/data/regression_suite/sqljson.sql --- - +ERROR@22: expected an expression, found R_PAREN +ERROR@22: expected expression +ERROR@1596: expected an expression, found R_PAREN +ERROR@1596: expected expression +ERROR@9659: missing comma +ERROR@9668: expected an expression, found WHERE_KW +ERROR@9673: expected R_PAREN +ERROR@9677: missing comma +ERROR@9681: expected SEMICOLON +ERROR@9681: expected command, found R_PAREN +ERROR@9683: expected command, found AS_KW +ERROR@9686: expected command, found IDENT +ERROR@9702: expected command, found COMMA +ERROR@9705: expected command, found JSON_ARRAYAGG_KW +ERROR@9719: expected R_PAREN +ERROR@9719: expected SEMICOLON +ERROR@9719: expected command, found IDENT +ERROR@9723: expected command, found ORDER_KW +ERROR@9729: expected command, found BY_KW +ERROR@9732: expected command, found IDENT +ERROR@9736: expected command, found RETURNING_KW +ERROR@9746: expected command, found IDENT +ERROR@9751: expected command, found R_PAREN +ERROR@9753: expected command, found FILTER_KW +ERROR@9761: expected R_PAREN +ERROR@9761: expected SEMICOLON +ERROR@9761: expected command, found WHERE_KW +ERROR@9767: expected command, found IDENT +ERROR@9771: expected command, found R_ANGLE +ERROR@9773: expected command, found INT_NUMBER +ERROR@9774: expected command, found R_PAREN +ERROR@9776: expected command, found AS_KW +ERROR@9779: expected command, found IDENT +ERROR@9812: expected command, found FROM_KW +ERROR@9882: expected SEMICOLON +ERROR@9883: expected command, found IDENT +ERROR@9887: expected R_PAREN +ERROR@9887: expected SEMICOLON +ERROR@9887: expected command, found IDENT +ERROR@9890: expected command, found R_PAREN +ERROR@9925: missing comma +ERROR@9934: expected an expression, found WHERE_KW +ERROR@9939: expected R_PAREN +ERROR@9943: missing comma +ERROR@9947: expected SEMICOLON +ERROR@9947: expected command, found R_PAREN +ERROR@9949: expected command, found OVER_KW +ERROR@9955: expected R_PAREN +ERROR@9955: expected SEMICOLON +ERROR@9955: expected command, found PARTITION_KW +ERROR@9965: expected command, found BY_KW +ERROR@9968: expected command, found IDENT +ERROR@9971: expected command, found DOT +ERROR@9972: expected command, found IDENT +ERROR@9976: expected command, found PERCENT +ERROR@9978: expected command, found INT_NUMBER +ERROR@9979: expected command, found R_PAREN +ERROR@9981: expected command, found FROM_KW +ERROR@10061: expected SEMICOLON +ERROR@10062: expected command, found IDENT +ERROR@10066: expected R_PAREN +ERROR@10066: expected SEMICOLON +ERROR@10066: expected command, found IDENT +ERROR@10069: expected command, found R_PAREN +ERROR@11936: missing comma +ERROR@11943: expected an expression, found ORDER_KW +ERROR@11948: expected R_PAREN +ERROR@11951: missing comma +ERROR@11953: expected SEMICOLON +ERROR@11953: expected command, found R_PAREN +ERROR@11955: expected command, found FROM_KW +ERROR@11981: expected SEMICOLON +ERROR@11982: expected command, found IDENT +ERROR@11984: expected R_PAREN +ERROR@11984: expected SEMICOLON +ERROR@11984: expected command, found IDENT +ERROR@11985: expected command, found COMMA +ERROR@11986: expected command, found IDENT +ERROR@11987: expected command, found R_PAREN +ERROR@12053: missing comma +ERROR@12060: expected an expression, found ORDER_KW +ERROR@12065: expected R_PAREN +ERROR@12068: missing comma +ERROR@12070: expected SEMICOLON +ERROR@12070: expected command, found R_PAREN +ERROR@12072: expected command, found FROM_KW +ERROR@12105: expected SEMICOLON +ERROR@12106: expected command, found IDENT +ERROR@12108: expected R_PAREN +ERROR@12108: expected SEMICOLON +ERROR@12108: expected command, found IDENT +ERROR@12109: expected command, found COMMA +ERROR@12110: expected command, found IDENT +ERROR@12111: expected command, found R_PAREN +ERROR@12192: missing comma +ERROR@12202: expected an expression, found ORDER_KW +ERROR@12207: expected R_PAREN +ERROR@12210: missing comma +ERROR@12212: expected SEMICOLON +ERROR@12212: expected command, found R_PAREN +ERROR@12214: expected command, found FROM_KW +ERROR@12250: expected SEMICOLON +ERROR@12251: expected command, found IDENT +ERROR@12253: expected R_PAREN +ERROR@12253: expected SEMICOLON +ERROR@12253: expected command, found IDENT +ERROR@12254: expected command, found COMMA +ERROR@12255: expected command, found IDENT +ERROR@12256: expected command, found R_PAREN +ERROR@12320: missing comma +ERROR@12327: expected an expression, found ORDER_KW +ERROR@12332: expected R_PAREN +ERROR@12335: missing comma +ERROR@12337: expected SEMICOLON +ERROR@12337: expected command, found R_PAREN +ERROR@12339: expected command, found FROM_KW +ERROR@12375: expected SEMICOLON +ERROR@12376: expected command, found IDENT +ERROR@12378: expected R_PAREN +ERROR@12378: expected SEMICOLON +ERROR@12378: expected command, found IDENT +ERROR@12379: expected command, found COMMA +ERROR@12380: expected command, found IDENT +ERROR@12381: expected command, found R_PAREN +ERROR@12445: missing comma +ERROR@12452: expected an expression, found ORDER_KW +ERROR@12457: expected R_PAREN +ERROR@12460: missing comma +ERROR@12468: missing comma +ERROR@12486: missing comma +ERROR@12520: expected SEMICOLON +ERROR@12520: expected command, found R_PAREN +ERROR@12522: expected command, found FROM_KW +ERROR@12558: expected SEMICOLON +ERROR@12559: expected command, found IDENT +ERROR@12561: expected R_PAREN +ERROR@12561: expected SEMICOLON +ERROR@12561: expected command, found IDENT +ERROR@12562: expected command, found COMMA +ERROR@12563: expected command, found IDENT +ERROR@12564: expected command, found R_PAREN +ERROR@12942: missing comma +ERROR@12951: expected an expression, found WHERE_KW +ERROR@12956: expected R_PAREN +ERROR@12958: missing comma +ERROR@12962: expected SEMICOLON +ERROR@12962: expected command, found R_PAREN +ERROR@12964: expected command, found FROM_KW +ERROR@12969: expected command, found IDENT +ERROR@12985: expected R_PAREN +ERROR@12985: expected SEMICOLON +ERROR@12985: expected command, found INT_NUMBER +ERROR@12986: expected command, found COMMA +ERROR@12987: expected command, found INT_NUMBER +ERROR@12988: expected command, found R_PAREN +ERROR@12990: expected command, found IDENT +ERROR@13107: missing comma +ERROR@13123: expected COMMA +ERROR@13126: expected COMMA +ERROR@13283: missing comma +ERROR@13292: expected an expression, found WHERE_KW +ERROR@13297: expected R_PAREN +ERROR@13299: missing comma +ERROR@13303: expected SEMICOLON +ERROR@13303: expected command, found R_PAREN +ERROR@13305: expected command, found FROM_KW +ERROR@13310: expected command, found IDENT +ERROR@13326: expected R_PAREN +ERROR@13326: expected SEMICOLON +ERROR@13326: expected command, found INT_NUMBER +ERROR@13327: expected command, found COMMA +ERROR@13328: expected command, found INT_NUMBER +ERROR@13329: expected command, found R_PAREN +ERROR@13331: expected command, found IDENT +ERROR@13510: missing comma +ERROR@13519: expected an expression, found WHERE_KW +ERROR@13524: expected R_PAREN +ERROR@13526: missing comma +ERROR@13530: expected SEMICOLON +ERROR@13530: expected command, found R_PAREN +ERROR@13532: expected command, found FROM_KW +ERROR@13537: expected command, found IDENT +ERROR@13553: expected R_PAREN +ERROR@13553: expected SEMICOLON +ERROR@13553: expected command, found INT_NUMBER +ERROR@13554: expected command, found COMMA +ERROR@13555: expected command, found INT_NUMBER +ERROR@13556: expected command, found R_PAREN +ERROR@13558: expected command, found IDENT +ERROR@13672: missing comma +ERROR@13688: expected COMMA +ERROR@13691: expected COMMA +ERROR@13844: missing comma +ERROR@13853: expected an expression, found WHERE_KW +ERROR@13858: expected R_PAREN +ERROR@13860: missing comma +ERROR@13864: expected SEMICOLON +ERROR@13864: expected command, found R_PAREN +ERROR@13866: expected command, found FROM_KW +ERROR@13871: expected command, found IDENT +ERROR@13887: expected R_PAREN +ERROR@13887: expected SEMICOLON +ERROR@13887: expected command, found INT_NUMBER +ERROR@13888: expected command, found COMMA +ERROR@13889: expected command, found INT_NUMBER +ERROR@13890: expected command, found R_PAREN +ERROR@13892: expected command, found IDENT 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..ba612ffc 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" @@ -2461,9 +2402,8 @@ SOURCE_FILE TARGET_LIST TARGET CALL_EXPR - NAME_REF + EXISTS_FN EXISTS_KW "exists" - ARG_LIST L_PAREN "(" SELECT SELECT_CLAUSE @@ -2502,9 +2442,8 @@ SOURCE_FILE TARGET_LIST TARGET CALL_EXPR - NAME_REF + EXISTS_FN EXISTS_KW "exists" - ARG_LIST L_PAREN "(" SELECT WITH_CLAUSE @@ -2552,9 +2491,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 +2527,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 +2553,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 +2694,8 @@ SOURCE_FILE TARGET_LIST TARGET CALL_EXPR - NAME_REF + EXTRACT_FN EXTRACT_KW "extract" - ARG_LIST L_PAREN "(" IDENT "foo" WHITESPACE " " @@ -2786,9 +2721,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 +2740,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 +2759,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 +2778,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 +2797,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 +2816,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 +2835,8 @@ SOURCE_FILE TARGET_LIST TARGET CALL_EXPR - NAME_REF + EXTRACT_FN EXTRACT_KW "extract" - ARG_LIST L_PAREN "(" STRING "'minute'" WHITESPACE " " @@ -2926,9 +2854,8 @@ SOURCE_FILE TARGET_LIST TARGET CALL_EXPR - NAME_REF + EXTRACT_FN EXTRACT_KW "extract" - ARG_LIST L_PAREN "(" IDENT "epoch" WHITESPACE " " @@ -2953,9 +2880,8 @@ SOURCE_FILE TARGET_LIST TARGET CALL_EXPR - NAME_REF + EXTRACT_FN EXTRACT_KW "extract" - ARG_LIST L_PAREN "(" IDENT "century" WHITESPACE " " @@ -2977,9 +2903,8 @@ SOURCE_FILE TARGET_LIST TARGET CALL_EXPR - NAME_REF + EXTRACT_FN EXTRACT_KW "extract" - ARG_LIST L_PAREN "(" IDENT "isodow" WHITESPACE " " @@ -3001,9 +2926,8 @@ SOURCE_FILE TARGET_LIST TARGET CALL_EXPR - NAME_REF + EXTRACT_FN EXTRACT_KW "extract" - ARG_LIST L_PAREN "(" IDENT "isoyear" WHITESPACE " " @@ -3028,9 +2952,8 @@ SOURCE_FILE TARGET_LIST TARGET CALL_EXPR - NAME_REF + EXTRACT_FN EXTRACT_KW "extract" - ARG_LIST L_PAREN "(" IDENT "julian" WHITESPACE " " @@ -3055,9 +2978,8 @@ SOURCE_FILE TARGET_LIST TARGET CALL_EXPR - NAME_REF + EXTRACT_FN EXTRACT_KW "extract" - ARG_LIST L_PAREN "(" IDENT "microseconds" WHITESPACE " " @@ -3079,9 +3001,8 @@ SOURCE_FILE TARGET_LIST TARGET CALL_EXPR - NAME_REF + EXTRACT_FN EXTRACT_KW "extract" - ARG_LIST L_PAREN "(" IDENT "millennium" WHITESPACE " " @@ -3103,9 +3024,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 "'\n \n the great gatsby\n f. scott fitzgerald\n 1925\n 12.99\n \n \n 1984\n george orwell\n 1949\n 14.99\n \n \n to kill a mockingbird\n harper lee\n 1960\n 13.99\n \n '" + 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_syntax/src/ast/generated/nodes.rs b/crates/squawk_syntax/src/ast/generated/nodes.rs index cd749f74..3593499d 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 { + support::child(&self.syntax) + } + #[inline] + pub fn select_variant(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn all_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn select_variant(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn any_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ANY_KW) + } +} + #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Arg { pub(crate) syntax: SyntaxNode, @@ -2074,26 +2128,126 @@ pub struct CallExpr { pub(crate) syntax: SyntaxNode, } impl CallExpr { + #[inline] + pub fn all_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn any_fn(&self) -> Option { + support::child(&self.syntax) + } #[inline] pub fn arg_list(&self) -> Option { support::child(&self.syntax) } #[inline] + pub fn exists_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] + pub fn extract_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn filter_clause(&self) -> Option { support::child(&self.syntax) } #[inline] + pub fn json_array_agg_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_array_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_exists_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_object_agg_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_object_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_query_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_serialize_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_value_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn over_clause(&self) -> Option { support::child(&self.syntax) } #[inline] + pub fn overlay_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn position_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn some_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn substring_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn trim_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn within_clause(&self) -> Option { support::child(&self.syntax) } + #[inline] + pub fn xml_element_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn xml_exists_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn xml_forest_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn xml_parse_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn xml_pi_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn xml_root_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn xml_serialize_fn(&self) -> Option { + support::child(&self.syntax) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -2144,6 +2298,10 @@ impl CastExpr { support::child(&self.syntax) } #[inline] + pub fn literal(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn ty(&self) -> Option { support::child(&self.syntax) } @@ -2163,6 +2321,10 @@ impl CastExpr { pub fn cast_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::CAST_KW) } + #[inline] + pub fn treat_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TREAT_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -2697,6 +2859,10 @@ impl ConstraintExclusion { support::child(&self.syntax) } #[inline] + pub fn op(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn with_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::WITH_KW) } @@ -2766,29 +2932,6 @@ impl ConstraintIndexTablespace { } } -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ConstraintWhereClause { - pub(crate) syntax: SyntaxNode, -} -impl ConstraintWhereClause { - #[inline] - pub fn expr(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) - } - #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) - } - #[inline] - pub fn where_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WHERE_KW) - } -} - #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Copy { pub(crate) syntax: SyntaxNode, @@ -3237,6 +3380,14 @@ pub struct CreateForeignDataWrapper { pub(crate) syntax: SyntaxNode, } impl CreateForeignDataWrapper { + #[inline] + pub fn alter_option_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn fdw_option_list(&self) -> Option { + support::child(&self.syntax) + } #[inline] pub fn name(&self) -> Option { support::child(&self.syntax) @@ -3264,15 +3415,31 @@ pub struct CreateForeignTable { pub(crate) syntax: SyntaxNode, } impl CreateForeignTable { + #[inline] + pub fn alter_option_list(&self) -> Option { + support::child(&self.syntax) + } #[inline] pub fn if_not_exists(&self) -> Option { support::child(&self.syntax) } #[inline] + pub fn inherits(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] + pub fn partition_of(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn partition_type(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn path(&self) -> Option { support::child(&self.syntax) } @@ -3437,13 +3604,41 @@ impl CreateLanguage { support::child(&self.syntax) } #[inline] + pub fn or_replace(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn path(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn create_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::CREATE_KW) } #[inline] + pub fn handler_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::HANDLER_KW) + } + #[inline] + pub fn inline_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INLINE_KW) + } + #[inline] pub fn language_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::LANGUAGE_KW) } + #[inline] + pub fn procedural_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PROCEDURAL_KW) + } + #[inline] + pub fn trusted_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRUSTED_KW) + } + #[inline] + pub fn validator_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VALIDATOR_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -3627,6 +3822,10 @@ pub struct CreatePolicy { pub(crate) syntax: SyntaxNode, } impl CreatePolicy { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } #[inline] pub fn name(&self) -> Option { support::child(&self.syntax) @@ -3636,58 +3835,142 @@ impl CreatePolicy { support::child(&self.syntax) } #[inline] - pub fn create_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CREATE_KW) + pub fn role_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn policy_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::POLICY_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct CreateProcedure { - pub(crate) syntax: SyntaxNode, -} -impl CreateProcedure { #[inline] - pub fn option_list(&self) -> Option { - support::child(&self.syntax) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn param_list(&self) -> Option { - support::child(&self.syntax) + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) } #[inline] - pub fn path(&self) -> Option { - support::child(&self.syntax) + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) + } + #[inline] + pub fn check_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CHECK_KW) } #[inline] pub fn create_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::CREATE_KW) } #[inline] - pub fn procedure_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PROCEDURE_KW) + pub fn delete_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DELETE_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct CreatePublication { - pub(crate) syntax: SyntaxNode, -} -impl CreatePublication { #[inline] - pub fn name(&self) -> Option { - support::child(&self.syntax) + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) } #[inline] - pub fn create_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CREATE_KW) + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) } #[inline] - pub fn publication_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PUBLICATION_KW) + pub fn insert_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INSERT_KW) + } + #[inline] + pub fn policy_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::POLICY_KW) + } + #[inline] + pub fn select_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SELECT_KW) + } + #[inline] + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) + } + #[inline] + pub fn update_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UPDATE_KW) + } + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } + #[inline] + pub fn with_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn or_replace(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn param_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn path(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn procedure_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn publication_objects(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn with_params(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) + } + #[inline] + pub fn publication_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PUBLICATION_KW) + } + #[inline] + pub fn tables_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLES_KW) } } @@ -3701,6 +3984,10 @@ impl CreateRole { support::child(&self.syntax) } #[inline] + pub fn role_option_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn create_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::CREATE_KW) } @@ -3880,18 +4167,54 @@ pub struct CreateServer { pub(crate) syntax: SyntaxNode, } impl CreateServer { + #[inline] + pub fn alter_option_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn if_not_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn literal(&self) -> Option { + support::child(&self.syntax) + } #[inline] pub fn name(&self) -> Option { support::child(&self.syntax) } #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn create_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::CREATE_KW) } #[inline] + pub fn data_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DATA_KW) + } + #[inline] + pub fn foreign_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOREIGN_KW) + } + #[inline] pub fn server_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::SERVER_KW) } + #[inline] + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) + } + #[inline] + pub fn version_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VERSION_KW) + } + #[inline] + pub fn wrapper_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WRAPPER_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -3930,15 +4253,35 @@ pub struct CreateSubscription { pub(crate) syntax: SyntaxNode, } impl CreateSubscription { + #[inline] + pub fn literal(&self) -> Option { + support::child(&self.syntax) + } #[inline] pub fn name(&self) -> Option { support::child(&self.syntax) } #[inline] + pub fn name_refs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn with_params(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn connection_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONNECTION_KW) + } + #[inline] pub fn create_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::CREATE_KW) } #[inline] + pub fn publication_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PUBLICATION_KW) + } + #[inline] pub fn subscription_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW) } @@ -4002,9 +4345,29 @@ impl CreateTable { support::token(&self.syntax, SyntaxKind::CREATE_KW) } #[inline] + pub fn global_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GLOBAL_KW) + } + #[inline] + pub fn local_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LOCAL_KW) + } + #[inline] pub fn table_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::TABLE_KW) } + #[inline] + pub fn temp_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEMP_KW) + } + #[inline] + pub fn temporary_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEMPORARY_KW) + } + #[inline] + pub fn unlogged_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNLOGGED_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -4049,6 +4412,10 @@ impl CreateTableAs { support::child(&self.syntax) } #[inline] + pub fn without_oids(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn as_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::AS_KW) } @@ -4057,9 +4424,29 @@ impl CreateTableAs { support::token(&self.syntax, SyntaxKind::CREATE_KW) } #[inline] + pub fn global_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GLOBAL_KW) + } + #[inline] + pub fn local_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LOCAL_KW) + } + #[inline] pub fn table_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::TABLE_KW) } + #[inline] + pub fn temp_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEMP_KW) + } + #[inline] + pub fn temporary_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEMPORARY_KW) + } + #[inline] + pub fn unlogged_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNLOGGED_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -4436,6 +4823,10 @@ impl CreateUser { support::child(&self.syntax) } #[inline] + pub fn role_option_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn create_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::CREATE_KW) } @@ -4455,6 +4846,10 @@ impl CreateUserMapping { support::child(&self.syntax) } #[inline] + pub fn if_not_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn name_ref(&self) -> Option { support::child(&self.syntax) } @@ -4538,6 +4933,14 @@ impl CreateView { support::token(&self.syntax, SyntaxKind::RECURSIVE_KW) } #[inline] + pub fn temp_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEMP_KW) + } + #[inline] + pub fn temporary_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEMPORARY_KW) + } + #[inline] pub fn view_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::VIEW_KW) } @@ -5334,8 +5737,12 @@ impl DropForeignDataWrapper { support::child(&self.syntax) } #[inline] - pub fn name_ref(&self) -> Option { - support::child(&self.syntax) + pub fn name_refs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn cascade_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CASCADE_KW) } #[inline] pub fn data_token(&self) -> Option { @@ -5350,6 +5757,10 @@ impl DropForeignDataWrapper { support::token(&self.syntax, SyntaxKind::FOREIGN_KW) } #[inline] + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + } + #[inline] pub fn wrapper_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::WRAPPER_KW) } @@ -5369,6 +5780,10 @@ impl DropForeignTable { support::child(&self.syntax) } #[inline] + pub fn cascade_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CASCADE_KW) + } + #[inline] pub fn drop_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::DROP_KW) } @@ -5377,6 +5792,10 @@ impl DropForeignTable { support::token(&self.syntax, SyntaxKind::FOREIGN_KW) } #[inline] + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + } + #[inline] pub fn table_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::TABLE_KW) } @@ -5396,6 +5815,10 @@ impl DropFunction { support::child(&self.syntax) } #[inline] + pub fn cascade_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CASCADE_KW) + } + #[inline] pub fn drop_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::DROP_KW) } @@ -5403,6 +5826,10 @@ impl DropFunction { pub fn function_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::FUNCTION_KW) } + #[inline] + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -5488,6 +5915,10 @@ impl DropLanguage { support::child(&self.syntax) } #[inline] + pub fn cascade_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CASCADE_KW) + } + #[inline] pub fn drop_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::DROP_KW) } @@ -5495,6 +5926,14 @@ impl DropLanguage { pub fn language_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::LANGUAGE_KW) } + #[inline] + pub fn procedural_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PROCEDURAL_KW) + } + #[inline] + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -5714,18 +6153,30 @@ pub struct DropOwned { pub(crate) syntax: SyntaxNode, } impl DropOwned { + #[inline] + pub fn role_list(&self) -> Option { + support::child(&self.syntax) + } #[inline] pub fn by_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::BY_KW) } #[inline] - pub fn drop_token(&self) -> Option { + pub fn cascade_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CASCADE_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::DROP_KW) } #[inline] pub fn owned_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::OWNED_KW) } + #[inline] + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -6647,11 +7098,11 @@ impl ExcludeConstraint { support::child(&self.syntax) } #[inline] - pub fn constraint_where_clause(&self) -> Option { + pub fn name(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn name(&self) -> Option { + pub fn where_condition_clause(&self) -> Option { support::child(&self.syntax) } #[inline] @@ -6683,6 +7134,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 { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn exists_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXISTS_KW) + } +} + #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Explain { pub(crate) syntax: SyntaxNode, @@ -6698,6 +7172,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 { + support::child(&self.syntax) + } + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } +} + #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ExprType { pub(crate) syntax: SyntaxNode, @@ -6709,6 +7198,65 @@ impl ExprType { } } +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExtractFn { + pub(crate) syntax: SyntaxNode, +} +impl ExtractFn { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn day_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DAY_KW) + } + #[inline] + pub fn extract_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXTRACT_KW) + } + #[inline] + pub fn from_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FROM_KW) + } + #[inline] + pub fn hour_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::HOUR_KW) + } + #[inline] + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) + } + #[inline] + pub fn minute_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MINUTE_KW) + } + #[inline] + pub fn month_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MONTH_KW) + } + #[inline] + pub fn second_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SECOND_KW) + } + #[inline] + pub fn string_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STRING_KW) + } + #[inline] + pub fn year_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::YEAR_KW) + } +} + #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct FatArrow { pub(crate) syntax: SyntaxNode, @@ -7011,10 +7559,18 @@ impl FromItem { support::child(&self.syntax) } #[inline] + pub fn cast_expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn field_expr(&self) -> Option { support::child(&self.syntax) } #[inline] + pub fn json_table(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn name_ref(&self) -> Option { support::child(&self.syntax) } @@ -7023,6 +7579,14 @@ impl FromItem { support::child(&self.syntax) } #[inline] + pub fn tablesample_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn xml_table(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn l_paren_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::L_PAREN) } @@ -7043,9 +7607,17 @@ impl FromItem { support::token(&self.syntax, SyntaxKind::ONLY_KW) } #[inline] + pub fn ordinality_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ORDINALITY_KW) + } + #[inline] pub fn rows_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::ROWS_KW) } + #[inline] + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -8263,6 +8835,87 @@ impl JoinUsingClause { } } +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct JsonArrayAggFn { + pub(crate) syntax: SyntaxNode, +} +impl JsonArrayAggFn { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_null_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_returning_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_select_formats(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn json_arrayagg_token(&self) -> Option { + 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 { + support::children(&self.syntax) + } + #[inline] + pub fn json_null_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_returning_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_select_formats(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn json_array_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } +} + #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct JsonBehaviorDefault { pub(crate) syntax: SyntaxNode, @@ -8364,244 +9017,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 { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] pub fn encoding_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::ENCODING_KW) } - #[inline] - pub fn format_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FORMAT_KW) - } - #[inline] - pub fn json_token(&self) -> Option { - 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 { support::child(&self.syntax) } #[inline] - pub fn json_value_expr(&self) -> Option { + pub fn json_format_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn colon_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COLON) + pub fn json_on_error_clause(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::KEYS_KW) + pub fn json_passing_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn unique_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::UNIQUE_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn without_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITHOUT_KW) + pub fn comma_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMA) + } + #[inline] + pub fn json_exists_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::ABSENT_KW) - } +impl JsonExprFormat { #[inline] - pub fn null_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULL_KW) + pub fn expr(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn json_format_clause(&self) -> Option { + 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 { + pub fn json_expr_format(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn empty_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EMPTY_KW) + pub fn json_keys_unique_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct JsonOnErrorClause { - pub(crate) syntax: SyntaxNode, -} -impl JsonOnErrorClause { #[inline] - pub fn json_behavior(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn error_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ERROR_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn json_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::JSON_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct JsonPassingArg { +pub struct JsonFormatClause { pub(crate) syntax: SyntaxNode, } -impl JsonPassingArg { - #[inline] - pub fn expr(&self) -> Option { - support::child(&self.syntax) - } +impl JsonFormatClause { #[inline] - pub fn json_format_clause(&self) -> Option { + pub fn json_encoding_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn name(&self) -> Option { - support::child(&self.syntax) + pub fn format_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FORMAT_KW) } #[inline] - pub fn as_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AS_KW) + pub fn json_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::JSON_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct JsonPassingClause { +pub struct JsonKeyValue { pub(crate) syntax: SyntaxNode, } -impl JsonPassingClause { +impl JsonKeyValue { #[inline] - pub fn json_passing_args(&self) -> AstChildren { - support::children(&self.syntax) + pub fn expr(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn passing_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PASSING_KW) + pub fn json_value_expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn colon_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLON) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct JsonQuotesClause { +pub struct JsonKeysUniqueClause { pub(crate) syntax: SyntaxNode, } -impl JsonQuotesClause { +impl JsonKeysUniqueClause { #[inline] - pub fn keep_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::KEEP_KW) + pub fn keys_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::KEYS_KW) } #[inline] - pub fn omit_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OMIT_KW) + pub fn unique_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNIQUE_KW) } #[inline] - pub fn quotes_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::QUOTES_KW) + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) + } + #[inline] + pub fn without_token(&self) -> Option { + 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 { - support::child(&self.syntax) + pub fn absent_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ABSENT_KW) } #[inline] - pub fn returning_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RETURNING_KW) + pub fn null_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULL_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + 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 { + pub fn json_key_value(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn name(&self) -> Option { + pub fn json_keys_unique_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn ty(&self) -> Option { + pub fn json_null_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn for_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FOR_KW) + pub fn returning_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn nested_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NESTED_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn ordinality_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ORDINALITY_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn path_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PATH_KW) + pub fn json_objectagg_token(&self) -> Option { + 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 { + pub fn json_key_values(&self) -> AstChildren { support::children(&self.syntax) } #[inline] + pub fn json_keys_unique_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_null_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_returning_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn l_paren_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::L_PAREN) } @@ -8610,1931 +9257,1834 @@ impl JsonTableColumnList { support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn columns_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COLUMNS_KW) + pub fn json_object_token(&self) -> Option { + 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 { + pub fn json_behavior(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn json_format_clause(&self) -> Option { - support::child(&self.syntax) + pub fn empty_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EMPTY_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::CONDITIONAL_KW) - } +impl JsonOnErrorClause { #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn json_behavior(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn without_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITHOUT_KW) + pub fn error_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ERROR_KW) } #[inline] - pub fn wrapper_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WRAPPER_KW) + pub fn on_token(&self) -> Option { + 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 { + pub fn expr(&self) -> Option { support::child(&self.syntax) } - #[inline] - pub fn language_token(&self) -> Option { - 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 { - support::token(&self.syntax, SyntaxKind::LEAKPROOF_KW) + pub fn json_passing_args(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn passing_token(&self) -> Option { + 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 { - support::children(&self.syntax) - } +impl JsonPathClause { #[inline] - pub fn path(&self) -> Option { + pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn like_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LIKE_KW) + pub fn path_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::ALL_KW) - } +impl JsonQueryFn { #[inline] - pub fn comments_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COMMENTS_KW) + pub fn expr(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn compression_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COMPRESSION_KW) + pub fn json_behavior_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn constraints_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CONSTRAINTS_KW) + pub fn json_format_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn defaults_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFAULTS_KW) + pub fn json_passing_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn excluding_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EXCLUDING_KW) + pub fn json_quotes_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn generated_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::GENERATED_KW) + pub fn json_returning_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn identity_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IDENTITY_KW) + pub fn json_wrapper_behavior_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn including_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INCLUDING_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn indexes_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INDEXES_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn statistics_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::STATISTICS_KW) + pub fn comma_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMA) } #[inline] - pub fn storage_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::STORAGE_KW) + pub fn json_query_token(&self) -> Option { + 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 { - support::child(&self.syntax) + pub fn keep_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::KEEP_KW) } #[inline] - pub fn all_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ALL_KW) + pub fn omit_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OMIT_KW) } #[inline] - pub fn limit_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LIMIT_KW) + pub fn quotes_token(&self) -> Option { + 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 { - support::children(&self.syntax) + pub fn ty(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn limit_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LIMIT_KW) - } - #[inline] - pub fn to_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TO_KW) + pub fn returning_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RETURNING_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Listen { +pub struct JsonSelectFormat { pub(crate) syntax: SyntaxNode, } -impl Listen { +impl JsonSelectFormat { #[inline] - pub fn name(&self) -> Option { + pub fn json_format_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn listen_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LISTEN_KW) + pub fn select_variant(&self) -> Option { + support::child(&self.syntax) } } #[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 JsonSerializeFn { pub(crate) syntax: SyntaxNode, } -impl Load { +impl JsonSerializeFn { #[inline] - pub fn literal(&self) -> Option { + pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn load_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LOAD_KW) + pub fn json_format_clause(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Lock { - pub(crate) syntax: SyntaxNode, -} -impl Lock { #[inline] - pub fn table_list(&self) -> Option { + pub fn json_returning_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn lock_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LOCK_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn table_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TABLE_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LockingClause { - pub(crate) syntax: SyntaxNode, -} -impl LockingClause { #[inline] - pub fn for_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FOR_KW) + pub fn json_serialize_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::JSON_SERIALIZE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Lteq { +pub struct JsonTable { pub(crate) syntax: SyntaxNode, } -impl Lteq { +impl JsonTable { #[inline] - pub fn l_angle_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_ANGLE) + pub fn expr(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn eq_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EQ) + pub fn json_format_clause(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchFull { - pub(crate) syntax: SyntaxNode, -} -impl MatchFull { #[inline] - pub fn full_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FULL_KW) + pub fn json_on_error_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn match_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MATCH_KW) + pub fn json_passing_clause(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::MATCH_KW) + pub fn json_table_column_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn partial_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PARTIAL_KW) + pub fn name(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::MATCH_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn simple_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SIMPLE_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Materialized { - pub(crate) syntax: SyntaxNode, -} -impl Materialized { #[inline] - pub fn materialized_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW) + pub fn comma_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMA) + } + #[inline] + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) + } + #[inline] + pub fn json_table_token(&self) -> Option { + 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 { + pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn merge_when_clauses(&self) -> AstChildren { - support::children(&self.syntax) - } - #[inline] - pub fn relation_name(&self) -> Option { + pub fn json_format_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn using_on_clause(&self) -> Option { + pub fn json_on_empty_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn into_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INTO_KW) + pub fn json_on_error_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn merge_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MERGE_KW) + pub fn json_path_clause(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::DELETE_KW) + pub fn json_quotes_clause(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::DO_KW) + pub fn json_table_column_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn nothing_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOTHING_KW) + pub fn json_wrapper_behavior_clause(&self) -> Option { + 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 { + pub fn name(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn values(&self) -> Option { + pub fn ty(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn default_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) } #[inline] - pub fn insert_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INSERT_KW) + pub fn exists_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXISTS_KW) } #[inline] - pub fn overriding_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OVERRIDING_KW) + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) } #[inline] - pub fn system_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SYSTEM_KW) + pub fn nested_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NESTED_KW) } #[inline] - pub fn user_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::USER_KW) + pub fn ordinality_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ORDINALITY_KW) } #[inline] - pub fn values_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::VALUES_KW) + pub fn path_token(&self) -> Option { + 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 { - support::child(&self.syntax) + pub fn json_table_columns(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn update_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::UPDATE_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn columns_token(&self) -> Option { + 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 { support::child(&self.syntax) } #[inline] - pub fn merge_action(&self) -> Option { + pub fn json_format_clause(&self) -> Option { support::child(&self.syntax) } - #[inline] - pub fn and_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AND_KW) - } - #[inline] - pub fn matched_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MATCHED_KW) - } - #[inline] - pub fn then_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::THEN_KW) - } - #[inline] - pub fn when_token(&self) -> Option { - 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 { support::child(&self.syntax) } #[inline] - pub fn merge_action(&self) -> Option { + pub fn json_behavior_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn and_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AND_KW) + pub fn json_format_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn by_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::BY_KW) + pub fn json_passing_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn matched_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MATCHED_KW) + pub fn json_returning_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn source_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SOURCE_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn then_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::THEN_KW) + pub fn comma_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMA) } #[inline] - pub fn when_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WHEN_KW) + pub fn json_value_token(&self) -> Option { + 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 { - support::child(&self.syntax) - } - #[inline] - pub fn merge_action(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn and_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AND_KW) - } +impl JsonWrapperBehaviorClause { #[inline] - pub fn by_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::BY_KW) + pub fn array_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ARRAY_KW) } #[inline] - pub fn matched_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MATCHED_KW) + pub fn conditional_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONDITIONAL_KW) } #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn unconditional_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNCONDITIONAL_KW) } #[inline] - pub fn target_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TARGET_KW) + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) } #[inline] - pub fn then_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::THEN_KW) + pub fn without_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITHOUT_KW) } #[inline] - pub fn when_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WHEN_KW) + pub fn wrapper_token(&self) -> Option { + 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 { support::child(&self.syntax) } #[inline] - pub fn from_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FROM_KW) - } - #[inline] - pub fn in_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IN_KW) - } - #[inline] - pub fn move_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MOVE_KW) + pub fn language_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::IDENT) + pub fn leakproof_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::IDENT) + pub fn not_token(&self) -> Option { + 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 { - support::child(&self.syntax) + pub fn like_options(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn fat_arrow(&self) -> Option { + pub fn path(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn name_ref(&self) -> Option { - support::child(&self.syntax) + pub fn like_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::BANG) + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) } #[inline] - pub fn eq_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EQ) + pub fn comments_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::L_ANGLE) + pub fn compression_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMPRESSION_KW) } #[inline] - pub fn r_angle_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_ANGLE) + pub fn constraints_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::ACTION_KW) + pub fn defaults_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULTS_KW) } #[inline] - pub fn no_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NO_KW) + pub fn excluding_token(&self) -> Option { + 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 { - support::child(&self.syntax) + pub fn generated_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GENERATED_KW) } #[inline] - pub fn depends_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEPENDS_KW) + pub fn identity_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENTITY_KW) } #[inline] - pub fn extension_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EXTENSION_KW) + pub fn including_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INCLUDING_KW) } #[inline] - pub fn no_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NO_KW) + pub fn indexes_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INDEXES_KW) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn statistics_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STATISTICS_KW) + } + #[inline] + pub fn storage_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::FORCE_KW) - } - #[inline] - pub fn level_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LEVEL_KW) - } +impl LimitClause { #[inline] - pub fn no_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NO_KW) + pub fn expr(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn row_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ROW_KW) + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) } #[inline] - pub fn security_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SECURITY_KW) + pub fn limit_token(&self) -> Option { + 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 { - support::child(&self.syntax) + pub fn name_refs(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn inherit_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INHERIT_KW) + pub fn limit_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LIMIT_KW) } #[inline] - pub fn no_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NO_KW) + pub fn to_token(&self) -> Option { + 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 { + pub fn name(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn inherit_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INHERIT_KW) - } - #[inline] - pub fn no_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NO_KW) + pub fn listen_token(&self) -> Option { + 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 { + pub fn literal(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn colon_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COLON) + pub fn load_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW) + pub fn table_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn lock_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LOCK_KW) + } + #[inline] + pub fn table_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW) - } +impl LockingClause { #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn for_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::ENFORCED_KW) + pub fn l_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_ANGLE) } #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn eq_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::ILIKE_KW) + pub fn full_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FULL_KW) } #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn match_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::IN_KW) + pub fn match_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATCH_KW) } #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn partial_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::LIKE_KW) + pub fn match_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATCH_KW) } #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn simple_token(&self) -> Option { + 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 { support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW) } - #[inline] - pub fn not_token(&self) -> Option { - 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 { - #[inline] - pub fn name_ref(&self) -> Option { - support::child(&self.syntax) - } +impl Merge { #[inline] - pub fn no_inherit(&self) -> Option { + pub fn alias(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn constraint_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + pub fn merge_when_clauses(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn relation_name(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn null_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULL_KW) + pub fn using_on_clause(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NotOf { - pub(crate) syntax: SyntaxNode, -} -impl NotOf { #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn into_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INTO_KW) } #[inline] - pub fn of_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OF_KW) + pub fn merge_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MERGE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NotSimilarTo { +pub struct MergeDelete { pub(crate) syntax: SyntaxNode, } -impl NotSimilarTo { - #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) - } - #[inline] - pub fn similar_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SIMILAR_KW) - } +impl MergeDelete { #[inline] - pub fn to_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TO_KW) + pub fn delete_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DELETE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NotValid { +pub struct MergeDoNothing { pub(crate) syntax: SyntaxNode, } -impl NotValid { +impl MergeDoNothing { #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn do_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DO_KW) } #[inline] - pub fn valid_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::VALID_KW) + pub fn nothing_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOTHING_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Notify { +pub struct MergeInsert { pub(crate) syntax: SyntaxNode, } -impl Notify { +impl MergeInsert { #[inline] - pub fn literal(&self) -> Option { + pub fn column_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn name_ref(&self) -> Option { + pub fn values(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn comma_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COMMA) - } - #[inline] - pub fn notify_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOTIFY_KW) + pub fn default_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULT_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NullConstraint { - pub(crate) syntax: SyntaxNode, -} -impl NullConstraint { #[inline] - pub fn name_ref(&self) -> Option { - support::child(&self.syntax) + pub fn insert_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INSERT_KW) } #[inline] - pub fn constraint_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + pub fn overriding_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OVERRIDING_KW) } #[inline] - pub fn null_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULL_KW) + pub fn system_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SYSTEM_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NullsDistinct { - pub(crate) syntax: SyntaxNode, -} -impl NullsDistinct { #[inline] - pub fn distinct_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DISTINCT_KW) + pub fn user_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USER_KW) } #[inline] - pub fn nulls_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULLS_KW) + pub fn values_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VALUES_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NullsFirst { +pub struct MergeUpdate { pub(crate) syntax: SyntaxNode, } -impl NullsFirst { - #[inline] - pub fn first_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FIRST_KW) - } +impl MergeUpdate { #[inline] - pub fn nulls_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULLS_KW) + pub fn set_clause(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NullsLast { - pub(crate) syntax: SyntaxNode, -} -impl NullsLast { #[inline] - pub fn last_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LAST_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } #[inline] - pub fn nulls_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULLS_KW) + pub fn update_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UPDATE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NullsNotDistinct { +pub struct MergeWhenMatched { pub(crate) syntax: SyntaxNode, } -impl NullsNotDistinct { +impl MergeWhenMatched { #[inline] - pub fn distinct_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DISTINCT_KW) + pub fn expr(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn merge_action(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn nulls_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULLS_KW) + pub fn and_token(&self) -> Option { + 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 { - support::child(&self.syntax) + pub fn matched_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATCHED_KW) } #[inline] - pub fn of_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OF_KW) + pub fn then_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::THEN_KW) + } + #[inline] + pub fn when_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WHEN_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OffsetClause { +pub struct MergeWhenNotMatchedSource { pub(crate) syntax: SyntaxNode, } -impl OffsetClause { +impl MergeWhenNotMatchedSource { #[inline] pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn offset_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OFFSET_KW) + pub fn merge_action(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn row_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ROW_KW) + pub fn and_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AND_KW) } #[inline] - pub fn rows_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ROWS_KW) + pub fn by_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BY_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OnClause { - pub(crate) syntax: SyntaxNode, -} -impl OnClause { #[inline] - pub fn expr(&self) -> Option { - support::child(&self.syntax) + pub fn matched_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATCHED_KW) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OnCommit { - pub(crate) syntax: SyntaxNode, -} -impl OnCommit { #[inline] - pub fn on_commit_action(&self) -> Option { - support::child(&self.syntax) + pub fn source_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SOURCE_KW) } #[inline] - pub fn commit_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COMMIT_KW) + pub fn then_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::THEN_KW) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn when_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WHEN_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OnConflictClause { +pub struct MergeWhenNotMatchedTarget { pub(crate) syntax: SyntaxNode, } -impl OnConflictClause { +impl MergeWhenNotMatchedTarget { #[inline] - pub fn conflict_action(&self) -> Option { + pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn conflict_target(&self) -> Option { + pub fn merge_action(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn conflict_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CONFLICT_KW) + pub fn and_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AND_KW) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn by_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BY_KW) + } + #[inline] + pub fn matched_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATCHED_KW) + } + #[inline] + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) + } + #[inline] + pub fn target_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TARGET_KW) + } + #[inline] + pub fn then_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::THEN_KW) + } + #[inline] + pub fn when_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WHEN_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OnDeleteAction { +pub struct Move { pub(crate) syntax: SyntaxNode, } -impl OnDeleteAction { +impl Move { #[inline] - pub fn ref_action(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn delete_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DELETE_KW) + pub fn from_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FROM_KW) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn in_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IN_KW) + } + #[inline] + pub fn move_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MOVE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OnTable { +pub struct Name { pub(crate) syntax: SyntaxNode, } -impl OnTable { - #[inline] - pub fn path(&self) -> Option { - support::child(&self.syntax) - } +impl Name { #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OnUpdateAction { +pub struct NameRef { pub(crate) syntax: SyntaxNode, } -impl OnUpdateAction { - #[inline] - pub fn ref_action(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) - } +impl NameRef { #[inline] - pub fn update_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::UPDATE_KW) + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Op { +pub struct NamedArg { pub(crate) syntax: SyntaxNode, } -impl Op { +impl NamedArg { #[inline] - pub fn at_time_zone(&self) -> Option { + pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn colon_colon(&self) -> Option { + pub fn fat_arrow(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn colon_eq(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Neq { + pub(crate) syntax: SyntaxNode, +} +impl Neq { #[inline] - pub fn custom_op(&self) -> Option { - support::child(&self.syntax) + pub fn bang_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BANG) } #[inline] - pub fn fat_arrow(&self) -> Option { - support::child(&self.syntax) + pub fn eq_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EQ) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Neqb { + pub(crate) syntax: SyntaxNode, +} +impl Neqb { #[inline] - pub fn gteq(&self) -> Option { - support::child(&self.syntax) + pub fn l_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_ANGLE) } #[inline] - pub fn is_distinct_from(&self) -> Option { - support::child(&self.syntax) + pub fn r_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_ANGLE) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NoAction { + pub(crate) syntax: SyntaxNode, +} +impl NoAction { #[inline] - pub fn is_json(&self) -> Option { - support::child(&self.syntax) + pub fn action_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ACTION_KW) } #[inline] - pub fn is_json_array(&self) -> Option { - support::child(&self.syntax) + pub fn no_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NO_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NoDependsOnExtension { + pub(crate) syntax: SyntaxNode, +} +impl NoDependsOnExtension { #[inline] - pub fn is_json_object(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn is_json_scalar(&self) -> Option { - support::child(&self.syntax) + pub fn depends_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEPENDS_KW) } #[inline] - pub fn is_json_value(&self) -> Option { - support::child(&self.syntax) + pub fn extension_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXTENSION_KW) } #[inline] - pub fn is_not(&self) -> Option { - support::child(&self.syntax) + pub fn no_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NO_KW) } #[inline] - pub fn is_not_distinct_from(&self) -> Option { - support::child(&self.syntax) + pub fn on_token(&self) -> Option { + 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 is_not_json(&self) -> Option { - support::child(&self.syntax) + pub fn force_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FORCE_KW) } #[inline] - pub fn is_not_json_array(&self) -> Option { - support::child(&self.syntax) + pub fn level_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LEVEL_KW) } #[inline] - pub fn is_not_json_scalar(&self) -> Option { - support::child(&self.syntax) + pub fn no_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NO_KW) } #[inline] - pub fn is_not_json_value(&self) -> Option { - support::child(&self.syntax) + pub fn row_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROW_KW) } #[inline] - pub fn lteq(&self) -> Option { - support::child(&self.syntax) + pub fn security_token(&self) -> Option { + 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 neq(&self) -> Option { + pub fn path(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn neqb(&self) -> Option { - support::child(&self.syntax) + pub fn inherit_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INHERIT_KW) } #[inline] - pub fn not_ilike(&self) -> Option { - support::child(&self.syntax) + pub fn no_token(&self) -> Option { + 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 not_in(&self) -> Option { + pub fn path(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn not_like(&self) -> Option { - support::child(&self.syntax) + pub fn inherit_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INHERIT_KW) } #[inline] - pub fn not_similar_to(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn operator_call(&self) -> Option { - support::child(&self.syntax) + pub fn no_token(&self) -> Option { + 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 similar_to(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn percent_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PERCENT) - } - #[inline] - pub fn plus_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PLUS) - } - #[inline] - pub fn minus_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MINUS) - } - #[inline] - pub fn slash_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SLASH) - } - #[inline] pub fn colon_token(&self) -> Option { 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 { - support::token(&self.syntax, SyntaxKind::L_ANGLE) + pub fn deferrable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW) } #[inline] - pub fn eq_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EQ) + pub fn not_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::R_ANGLE) + pub fn deferrable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW) } #[inline] - pub fn caret_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CARET) + pub fn not_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::AND_KW) + pub fn enforced_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ENFORCED_KW) } #[inline] - pub fn collate_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COLLATE_KW) + pub fn not_token(&self) -> Option { + 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 { support::token(&self.syntax, SyntaxKind::ILIKE_KW) } + #[inline] + pub fn not_token(&self) -> Option { + 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 { support::token(&self.syntax, SyntaxKind::IN_KW) } #[inline] - pub fn is_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IS_KW) + pub fn not_token(&self) -> Option { + 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 { support::token(&self.syntax, SyntaxKind::LIKE_KW) } #[inline] - pub fn or_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OR_KW) + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NotMaterialized { + pub(crate) syntax: SyntaxNode, +} +impl NotMaterialized { #[inline] - pub fn overlaps_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OVERLAPS_KW) + pub fn materialized_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW) } #[inline] - pub fn value_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::VALUE_KW) + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OpClassOption { +pub struct NotNullConstraint { pub(crate) syntax: SyntaxNode, } -impl OpClassOption { +impl NotNullConstraint { #[inline] - pub fn function_sig(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn literal(&self) -> Option { + pub fn no_inherit(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn op(&self) -> Option { - support::child(&self.syntax) + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) } #[inline] - pub fn param_list(&self) -> Option { - support::child(&self.syntax) + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) } #[inline] - pub fn path(&self) -> Option { - support::child(&self.syntax) + pub fn null_token(&self) -> Option { + 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 ty(&self) -> Option { - support::child(&self.syntax) + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn of_token(&self) -> Option { + 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 r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) } #[inline] - pub fn comma_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COMMA) + pub fn similar_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SIMILAR_KW) } #[inline] - pub fn by_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::BY_KW) + pub fn to_token(&self) -> Option { + 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 for_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FOR_KW) + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) } #[inline] - pub fn function_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FUNCTION_KW) + pub fn valid_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VALID_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Notify { + pub(crate) syntax: SyntaxNode, +} +impl Notify { #[inline] - pub fn operator_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OPERATOR_KW) + pub fn literal(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn order_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ORDER_KW) + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn search_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SEARCH_KW) + pub fn comma_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMA) } #[inline] - pub fn storage_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::STORAGE_KW) + pub fn notify_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOTIFY_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OpSig { +pub struct NullConstraint { pub(crate) syntax: SyntaxNode, } -impl OpSig { +impl NullConstraint { #[inline] - pub fn op(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) - } - #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) - } - #[inline] - pub fn comma_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COMMA) + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) } #[inline] - pub fn none_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NONE_KW) + pub fn null_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULL_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OpSigList { +pub struct NullsDistinct { pub(crate) syntax: SyntaxNode, } -impl OpSigList { +impl NullsDistinct { #[inline] - pub fn op_sigs(&self) -> AstChildren { - support::children(&self.syntax) + pub fn distinct_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DISTINCT_KW) + } + #[inline] + pub fn nulls_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULLS_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OperatorCall { +pub struct NullsFirst { pub(crate) syntax: SyntaxNode, } -impl OperatorCall { +impl NullsFirst { #[inline] - pub fn op(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn path(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) - } - #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) - } - #[inline] - pub fn dot_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DOT) - } - #[inline] - pub fn operator_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OPERATOR_KW) + pub fn first_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FIRST_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OperatorClassOptionList { - pub(crate) syntax: SyntaxNode, -} -impl OperatorClassOptionList { #[inline] - pub fn op_class_options(&self) -> AstChildren { - support::children(&self.syntax) + pub fn nulls_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULLS_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OptionItem { +pub struct NullsLast { pub(crate) syntax: SyntaxNode, } -impl OptionItem { +impl NullsLast { #[inline] - pub fn expr(&self) -> Option { - support::child(&self.syntax) + pub fn last_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LAST_KW) } #[inline] - pub fn default_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + pub fn nulls_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULLS_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OptionItemList { +pub struct NullsNotDistinct { pub(crate) syntax: SyntaxNode, } -impl OptionItemList { +impl NullsNotDistinct { #[inline] - pub fn option_items(&self) -> AstChildren { - support::children(&self.syntax) + pub fn distinct_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DISTINCT_KW) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) } #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn nulls_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULLS_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OrReplace { +pub struct OfType { pub(crate) syntax: SyntaxNode, } -impl OrReplace { +impl OfType { #[inline] - pub fn or_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OR_KW) + pub fn ty(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn replace_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REPLACE_KW) + pub fn of_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OF_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OrderByClause { +pub struct OffsetClause { pub(crate) syntax: SyntaxNode, } -impl OrderByClause { +impl OffsetClause { #[inline] - pub fn sort_by_list(&self) -> Option { + pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn by_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::BY_KW) - } - #[inline] - pub fn order_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ORDER_KW) - } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OverClause { - pub(crate) syntax: SyntaxNode, -} -impl OverClause { - #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn offset_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OFFSET_KW) } #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn row_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROW_KW) } #[inline] - pub fn over_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OVER_KW) + pub fn rows_token(&self) -> Option { + 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 { + pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn owner_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OWNER_KW) - } - #[inline] - pub fn to_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TO_KW) + pub fn on_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::IDENT) + pub fn on_commit_action(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn parallel_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PARALLEL_KW) + pub fn commit_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMIT_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + 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 { + pub fn conflict_action(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn name(&self) -> Option { + pub fn conflict_target(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn param_default(&self) -> Option { - support::child(&self.syntax) + pub fn conflict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONFLICT_KW) } #[inline] - pub fn ty(&self) -> Option { - support::child(&self.syntax) + pub fn on_token(&self) -> Option { + 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 { + pub fn ref_action(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn eq_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EQ) + pub fn delete_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DELETE_KW) } #[inline] - pub fn default_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + pub fn on_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::IN_KW) + pub fn path(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn on_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::IN_KW) + pub fn ref_action(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn inout_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INOUT_KW) + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) } #[inline] - pub fn out_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OUT_KW) + pub fn update_token(&self) -> Option { + 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 { - support::children(&self.syntax) + pub fn at_time_zone(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::OUT_KW) + pub fn colon_colon(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::VARIADIC_KW) + pub fn colon_eq(&self) -> Option { + 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 { + pub fn custom_op(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn select(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn by_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::BY_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn owned_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OWNED_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ParenSelect { + pub(crate) syntax: SyntaxNode, +} +impl ParenSelect { + #[inline] + pub fn select(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn reassign_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REASSIGN_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn to_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TO_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ReferencesConstraint { +pub struct PartitionBy { pub(crate) syntax: SyntaxNode, } -impl ReferencesConstraint { +impl PartitionBy { #[inline] - pub fn match_type(&self) -> Option { + pub fn partition_item_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn name(&self) -> Option { - support::child(&self.syntax) + pub fn by_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BY_KW) } #[inline] - pub fn name_ref(&self) -> Option { - support::child(&self.syntax) + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) } #[inline] - pub fn on_delete_action(&self) -> Option { - support::child(&self.syntax) + pub fn partition_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PARTITION_KW) } #[inline] - pub fn on_update_action(&self) -> Option { - support::child(&self.syntax) + pub fn range_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RANGE_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PartitionDefault { + pub(crate) syntax: SyntaxNode, +} +impl PartitionDefault { #[inline] - pub fn path(&self) -> Option { - support::child(&self.syntax) + pub fn default_token(&self) -> Option { + 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 exprs(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] pub fn l_paren_token(&self) -> Option { @@ -11017,598 +11569,472 @@ impl ReferencesConstraint { support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn constraint_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) } #[inline] - pub fn references_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REFERENCES_KW) + pub fn from_token(&self) -> Option { + 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 { - support::children(&self.syntax) + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) } #[inline] - pub fn referencing_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REFERENCING_KW) + pub fn values_token(&self) -> Option { + 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 { - support::child(&self.syntax) + pub fn exprs(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn as_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AS_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn new_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NEW_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn old_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OLD_KW) + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) } #[inline] - pub fn table_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TABLE_KW) + pub fn in_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IN_KW) + } + #[inline] + pub fn values_token(&self) -> Option { + 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 { + pub fn literal(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn with_data(&self) -> Option { - support::child(&self.syntax) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn with_no_data(&self) -> Option { - support::child(&self.syntax) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn concurrently_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW) + pub fn comma_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMA) } #[inline] - pub fn materialized_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW) + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) } #[inline] - pub fn refresh_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REFRESH_KW) + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) } #[inline] - pub fn view_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::VIEW_KW) + pub fn values_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VALUES_KW) + } + #[inline] + pub fn with_token(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::COLLATION_KW) - } +impl PartitionItem { #[inline] - pub fn refresh_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REFRESH_KW) + pub fn collate(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn version_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::VERSION_KW) + pub fn expr(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::REFRESH_KW) + pub fn partition_items(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn version_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::VERSION_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + 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 { + pub fn ty(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn database_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DATABASE_KW) + pub fn of_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OF_KW) } #[inline] - pub fn index_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INDEX_KW) - } - #[inline] - pub fn reindex_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REINDEX_KW) - } - #[inline] - pub fn schema_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SCHEMA_KW) - } - #[inline] - pub fn system_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SYSTEM_KW) - } - #[inline] - pub fn table_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TABLE_KW) + pub fn partition_token(&self) -> Option { + 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 { + pub fn qualifier(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) - } - #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) - } - #[inline] - pub fn star_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::STAR) + pub fn segment(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn only_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ONLY_KW) + pub fn dot_token(&self) -> Option { + 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 { + pub fn name(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn release_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RELEASE_KW) - } - #[inline] - pub fn savepoint_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW) + pub fn name_ref(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::COLUMN_KW) - } +impl PathType { #[inline] - pub fn rename_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RENAME_KW) + pub fn arg_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn to_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TO_KW) + pub fn path(&self) -> Option { + 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 { - support::child(&self.syntax) - } - #[inline] - pub fn name_ref(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn constraint_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) - } +impl PercentType { #[inline] - pub fn rename_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RENAME_KW) + pub fn percent_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PERCENT) } #[inline] - pub fn to_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TO_KW) + pub fn type_token(&self) -> Option { + 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 { + pub fn path(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn rename_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RENAME_KW) - } - #[inline] - pub fn to_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TO_KW) + pub fn percent_type_clause(&self) -> Option { + 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 { - support::token(&self.syntax, SyntaxKind::ISOLATION_KW) + pub fn expr(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn level_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LEVEL_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn read_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::READ_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn repeatable_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REPEATABLE_KW) + pub fn in_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IN_KW) + } + #[inline] + pub fn position_token(&self) -> Option { + 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 { - #[inline] - pub fn identity_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IDENTITY_KW) - } +impl PostfixExpr { #[inline] - pub fn replica_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REPLICA_KW) + pub fn expr(&self) -> Option { + support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Reset { +pub struct PrefixExpr { pub(crate) syntax: SyntaxNode, } -impl Reset { +impl PrefixExpr { #[inline] - pub fn name_ref(&self) -> Option { + pub fn expr(&self) -> Option { support::child(&self.syntax) } - #[inline] - pub fn all_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ALL_KW) - } - #[inline] - pub fn reset_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESET_KW) - } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ResetConfigParam { +pub struct Prepare { pub(crate) syntax: SyntaxNode, } -impl ResetConfigParam { +impl Prepare { #[inline] - pub fn path(&self) -> Option { + pub fn name(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn all_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ALL_KW) + pub fn preparable_stmt(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn reset_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESET_KW) + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) + } + #[inline] + pub fn prepare_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PREPARE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ResetFuncOption { +pub struct PrepareTransaction { pub(crate) syntax: SyntaxNode, } -impl ResetFuncOption { +impl PrepareTransaction { #[inline] - pub fn name_ref(&self) -> Option { + pub fn literal(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn reset_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESET_KW) + pub fn prepare_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PREPARE_KW) + } + #[inline] + pub fn transaction_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRANSACTION_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ResetOptions { +pub struct PreserveRows { pub(crate) syntax: SyntaxNode, } -impl ResetOptions { - #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) - } +impl PreserveRows { #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn preserve_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PRESERVE_KW) } #[inline] - pub fn reset_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESET_KW) + pub fn rows_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROWS_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ResetSessionAuth { +pub struct PrimaryKeyConstraint { pub(crate) syntax: SyntaxNode, } -impl ResetSessionAuth { +impl PrimaryKeyConstraint { #[inline] - pub fn authorization_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW) + pub fn column_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn reset_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESET_KW) + pub fn name(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn session_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SESSION_KW) + pub fn partition_item_list(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Restart { - pub(crate) syntax: SyntaxNode, -} -impl Restart { #[inline] - pub fn restart_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESTART_KW) + pub fn using_index(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Restrict { - pub(crate) syntax: SyntaxNode, -} -impl Restrict { #[inline] - pub fn restrict_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + pub fn key_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::KEY_KW) + } + #[inline] + pub fn primary_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PRIMARY_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RetType { +pub struct PrivilegeTarget { pub(crate) syntax: SyntaxNode, } -impl RetType { +impl PrivilegeTarget { #[inline] - pub fn ty(&self) -> Option { - support::child(&self.syntax) + pub fn functions_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FUNCTIONS_KW) } #[inline] - pub fn returns_token(&self) -> Option { - 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 expr(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn return_token(&self) -> Option { - 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 returning_option_list(&self) -> Option { - support::child(&self.syntax) + pub fn large_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LARGE_KW) } #[inline] - pub fn target_list(&self) -> Option { - support::child(&self.syntax) + pub fn objects_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OBJECTS_KW) } #[inline] - pub fn returning_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RETURNING_KW) + pub fn routines_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROUTINES_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ReturningOption { - pub(crate) syntax: SyntaxNode, -} -impl ReturningOption { #[inline] - pub fn name(&self) -> Option { - support::child(&self.syntax) + pub fn schemas_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SCHEMAS_KW) } #[inline] - pub fn as_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AS_KW) + pub fn sequences_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEQUENCES_KW) } #[inline] - pub fn new_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NEW_KW) + pub fn tables_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLES_KW) } #[inline] - pub fn old_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OLD_KW) + pub fn types_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPES_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ReturningOptionList { +pub struct Privileges { pub(crate) syntax: SyntaxNode, } -impl ReturningOptionList { +impl Privileges { #[inline] - pub fn returning_options(&self) -> AstChildren { - support::children(&self.syntax) + pub fn column_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn revoke_command_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) } #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn privileges_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PRIVILEGES_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Revoke { +pub struct PublicationObject { pub(crate) syntax: SyntaxNode, } -impl Revoke { - #[inline] - pub fn name_refs(&self) -> AstChildren { - support::children(&self.syntax) - } - #[inline] - pub fn paths(&self) -> AstChildren { - support::children(&self.syntax) - } +impl PublicationObject { #[inline] - pub fn revoke_command_list(&self) -> Option { + pub fn column_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn role(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn role_list(&self) -> Option { + pub fn path(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn all_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ALL_KW) - } - #[inline] - pub fn by_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::BY_KW) - } - #[inline] - pub fn cascade_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CASCADE_KW) + pub fn where_condition_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn for_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FOR_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn from_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FROM_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn grant_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::GRANT_KW) + pub fn star_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STAR) } #[inline] - pub fn granted_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::GRANTED_KW) + pub fn current_schema_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CURRENT_SCHEMA_KW) } #[inline] pub fn in_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::IN_KW) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) - } - #[inline] - pub fn option_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OPTION_KW) - } - #[inline] - pub fn privileges_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PRIVILEGES_KW) - } - #[inline] - pub fn restrict_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESTRICT_KW) - } - #[inline] - pub fn revoke_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REVOKE_KW) + pub fn only_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ONLY_KW) } #[inline] pub fn schema_token(&self) -> Option { @@ -11625,2253 +12051,2264 @@ impl Revoke { } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RevokeCommand { +pub struct ReadCommitted { pub(crate) syntax: SyntaxNode, } -impl RevokeCommand { - #[inline] - pub fn role(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn all_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ALL_KW) - } - #[inline] - pub fn alter_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ALTER_KW) - } - #[inline] - pub fn create_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CREATE_KW) - } - #[inline] - pub fn delete_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DELETE_KW) - } - #[inline] - pub fn execute_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EXECUTE_KW) - } +impl ReadCommitted { #[inline] - pub fn ident_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IDENT) + pub fn committed_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMITTED_KW) } #[inline] - pub fn insert_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INSERT_KW) + pub fn isolation_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ISOLATION_KW) } #[inline] - pub fn references_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REFERENCES_KW) + pub fn level_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LEVEL_KW) } #[inline] - pub fn select_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SELECT_KW) + pub fn read_token(&self) -> Option { + 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 system_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SYSTEM_KW) + pub fn only_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ONLY_KW) } #[inline] - pub fn temp_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TEMP_KW) + pub fn read_token(&self) -> Option { + 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 temporary_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TEMPORARY_KW) + pub fn isolation_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ISOLATION_KW) } #[inline] - pub fn trigger_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TRIGGER_KW) + pub fn level_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LEVEL_KW) } #[inline] - pub fn truncate_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TRUNCATE_KW) + pub fn read_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::READ_KW) } #[inline] - pub fn update_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::UPDATE_KW) + pub fn uncommitted_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNCOMMITTED_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RevokeCommandList { +pub struct ReadWrite { pub(crate) syntax: SyntaxNode, } -impl RevokeCommandList { +impl ReadWrite { #[inline] - pub fn revoke_commands(&self) -> AstChildren { - support::children(&self.syntax) + pub fn read_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::READ_KW) + } + #[inline] + pub fn write_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WRITE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RevokeDefaultPrivileges { +pub struct Reassign { pub(crate) syntax: SyntaxNode, } -impl RevokeDefaultPrivileges { +impl Reassign { #[inline] - pub fn privilege_target(&self) -> Option { + pub fn new_roles(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn privileges(&self) -> Option { + pub fn old_roles(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn role_list(&self) -> Option { - support::child(&self.syntax) + pub fn by_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BY_KW) } #[inline] - pub fn cascade_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CASCADE_KW) + pub fn owned_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OWNED_KW) } #[inline] - pub fn for_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FOR_KW) + pub fn reassign_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REASSIGN_KW) } #[inline] - pub fn from_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FROM_KW) - } - #[inline] - pub fn grant_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::GRANT_KW) - } - #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) - } - #[inline] - pub fn option_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OPTION_KW) - } - #[inline] - pub fn restrict_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESTRICT_KW) - } - #[inline] - pub fn revoke_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::REVOKE_KW) + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Role { +pub struct ReferencesConstraint { pub(crate) syntax: SyntaxNode, } -impl Role { +impl ReferencesConstraint { + #[inline] + pub fn match_type(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name(&self) -> Option { + support::child(&self.syntax) + } #[inline] pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn current_role_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CURRENT_ROLE_KW) + pub fn on_delete_action(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn current_user_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CURRENT_USER_KW) + pub fn on_update_action(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn group_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::GROUP_KW) + pub fn path(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn session_user_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SESSION_USER_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RoleList { - pub(crate) syntax: SyntaxNode, -} -impl RoleList { #[inline] - pub fn roles(&self) -> AstChildren { - support::children(&self.syntax) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RoleOption { - pub(crate) syntax: SyntaxNode, -} -impl RoleOption { #[inline] - pub fn inherit_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INHERIT_KW) + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + } + #[inline] + pub fn references_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REFERENCES_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RoleOptionList { +pub struct Referencing { pub(crate) syntax: SyntaxNode, } -impl RoleOptionList { +impl Referencing { #[inline] - pub fn role_options(&self) -> AstChildren { + pub fn referencing_tables(&self) -> AstChildren { support::children(&self.syntax) } #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn referencing_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REFERENCING_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Rollback { +pub struct ReferencingTable { pub(crate) syntax: SyntaxNode, } -impl Rollback { +impl ReferencingTable { #[inline] - pub fn literal(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn name_ref(&self) -> Option { - support::child(&self.syntax) + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) } #[inline] - pub fn abort_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ABORT_KW) + pub fn new_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NEW_KW) } #[inline] - pub fn and_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AND_KW) + pub fn old_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OLD_KW) } #[inline] - pub fn chain_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CHAIN_KW) + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Refresh { + pub(crate) syntax: SyntaxNode, +} +impl Refresh { #[inline] - pub fn no_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NO_KW) + pub fn path(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn prepared_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PREPARED_KW) + pub fn with_data(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn rollback_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ROLLBACK_KW) + pub fn with_no_data(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn savepoint_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW) + pub fn concurrently_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW) } #[inline] - pub fn to_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TO_KW) + pub fn materialized_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW) } #[inline] - pub fn transaction_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TRANSACTION_KW) + pub fn refresh_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REFRESH_KW) } #[inline] - pub fn work_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WORK_KW) + pub fn view_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VIEW_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Row { +pub struct RefreshCollationVersion { pub(crate) syntax: SyntaxNode, } -impl Row { +impl RefreshCollationVersion { #[inline] - pub fn exprs(&self) -> AstChildren { - support::children(&self.syntax) + pub fn collation_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLLATION_KW) + } + #[inline] + pub fn refresh_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REFRESH_KW) + } + #[inline] + pub fn version_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VERSION_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RowList { +pub struct RefreshVersion { pub(crate) syntax: SyntaxNode, } -impl RowList { +impl RefreshVersion { #[inline] - pub fn rows(&self) -> AstChildren { - support::children(&self.syntax) + pub fn refresh_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REFRESH_KW) + } + #[inline] + pub fn version_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VERSION_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RowsFuncOption { +pub struct Reindex { pub(crate) syntax: SyntaxNode, } -impl RowsFuncOption { +impl Reindex { #[inline] - pub fn rows_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ROWS_KW) + pub fn path(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn database_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DATABASE_KW) + } + #[inline] + pub fn index_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INDEX_KW) + } + #[inline] + pub fn reindex_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REINDEX_KW) + } + #[inline] + pub fn schema_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SCHEMA_KW) + } + #[inline] + pub fn system_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SYSTEM_KW) + } + #[inline] + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Savepoint { +pub struct RelationName { pub(crate) syntax: SyntaxNode, } -impl Savepoint { +impl RelationName { #[inline] - pub fn name(&self) -> Option { + pub fn path(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn savepoint_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn star_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STAR) + } + #[inline] + pub fn only_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ONLY_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SchemaAuthorization { +pub struct ReleaseSavepoint { pub(crate) syntax: SyntaxNode, } -impl SchemaAuthorization { +impl ReleaseSavepoint { #[inline] - pub fn role(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn authorization_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW) + pub fn release_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RELEASE_KW) + } + #[inline] + pub fn savepoint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SecurityFuncOption { +pub struct RenameColumn { pub(crate) syntax: SyntaxNode, } -impl SecurityFuncOption { +impl RenameColumn { #[inline] - pub fn definer_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFINER_KW) + pub fn column_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLUMN_KW) } #[inline] - pub fn invoker_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INVOKER_KW) + pub fn rename_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RENAME_KW) } #[inline] - pub fn security_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SECURITY_KW) + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SecurityLabel { +pub struct RenameConstraint { pub(crate) syntax: SyntaxNode, } -impl SecurityLabel { +impl RenameConstraint { #[inline] - pub fn aggregate(&self) -> Option { + pub fn name(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn for_provider(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn function_sig(&self) -> Option { - support::child(&self.syntax) + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) } #[inline] - pub fn literal(&self) -> Option { - support::child(&self.syntax) + pub fn rename_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RENAME_KW) } #[inline] - pub fn path(&self) -> Option { + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RenameTo { + pub(crate) syntax: SyntaxNode, +} +impl RenameTo { + #[inline] + pub fn name(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn aggregate_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AGGREGATE_KW) + pub fn rename_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RENAME_KW) } #[inline] - pub fn column_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COLUMN_KW) + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RepeatableClause { + pub(crate) syntax: SyntaxNode, +} +impl RepeatableClause { #[inline] - pub fn database_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DATABASE_KW) + pub fn expr(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn domain_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DOMAIN_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn event_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EVENT_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn foreign_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FOREIGN_KW) + pub fn repeatable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REPEATABLE_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RepeatableRead { + pub(crate) syntax: SyntaxNode, +} +impl RepeatableRead { #[inline] - pub fn function_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FUNCTION_KW) + pub fn isolation_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ISOLATION_KW) } #[inline] - pub fn is_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IS_KW) + pub fn level_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LEVEL_KW) } #[inline] - pub fn label_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LABEL_KW) + pub fn read_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::READ_KW) } #[inline] - pub fn language_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LANGUAGE_KW) + pub fn repeatable_token(&self) -> Option { + 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 large_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LARGE_KW) + pub fn identity_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENTITY_KW) } #[inline] - pub fn materialized_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW) + pub fn replica_token(&self) -> Option { + 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 null_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULL_KW) + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn object_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OBJECT_KW) + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn reset_token(&self) -> Option { + 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 procedural_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PROCEDURAL_KW) + pub fn path(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn procedure_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PROCEDURE_KW) + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) } #[inline] - pub fn publication_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PUBLICATION_KW) + pub fn reset_token(&self) -> Option { + 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 role_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ROLE_KW) + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn routine_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ROUTINE_KW) + pub fn reset_token(&self) -> Option { + 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 schema_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SCHEMA_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn security_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SECURITY_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn sequence_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SEQUENCE_KW) + pub fn reset_token(&self) -> Option { + 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 subscription_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW) + pub fn authorization_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW) } #[inline] - pub fn table_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TABLE_KW) + pub fn reset_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESET_KW) } #[inline] - pub fn tablespace_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TABLESPACE_KW) + pub fn session_token(&self) -> Option { + 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 trigger_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TRIGGER_KW) + pub fn restart_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTART_KW) } #[inline] - pub fn type_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TYPE_KW) + pub fn with_token(&self) -> Option { + 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 view_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::VIEW_KW) + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Select { +pub struct RetType { pub(crate) syntax: SyntaxNode, } -impl Select { +impl RetType { #[inline] - pub fn fetch_clause(&self) -> Option { + pub fn ty(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn filter_clause(&self) -> Option { - support::child(&self.syntax) + pub fn returns_token(&self) -> Option { + 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 from_clause(&self) -> Option { + pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn group_by_clause(&self) -> Option { - support::child(&self.syntax) + pub fn return_token(&self) -> Option { + 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 having_clause(&self) -> Option { + pub fn returning_option_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn limit_clause(&self) -> Option { + pub fn target_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn locking_clauses(&self) -> AstChildren { - support::children(&self.syntax) + pub fn returning_token(&self) -> Option { + 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 offset_clause(&self) -> Option { + pub fn name(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn order_by_clause(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn select_clause(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn where_clause(&self) -> Option { - support::child(&self.syntax) + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) } #[inline] - pub fn window_clause(&self) -> Option { - support::child(&self.syntax) + pub fn new_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NEW_KW) } #[inline] - pub fn with_clause(&self) -> Option { - support::child(&self.syntax) + pub fn old_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OLD_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SelectClause { +pub struct ReturningOptionList { pub(crate) syntax: SyntaxNode, } -impl SelectClause { +impl ReturningOptionList { #[inline] - pub fn distinct_clause(&self) -> Option { - support::child(&self.syntax) + pub fn returning_options(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn target_list(&self) -> Option { - support::child(&self.syntax) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn all_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ALL_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn select_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SELECT_KW) + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SelectInto { +pub struct Revoke { pub(crate) syntax: SyntaxNode, } -impl SelectInto { - #[inline] - pub fn filter_clause(&self) -> Option { - support::child(&self.syntax) - } +impl Revoke { #[inline] - pub fn from_clause(&self) -> Option { - support::child(&self.syntax) + pub fn name_refs(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn group_by_clause(&self) -> Option { - support::child(&self.syntax) + pub fn paths(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn having_clause(&self) -> Option { + pub fn revoke_command_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn into_clause(&self) -> Option { + pub fn role(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn limit_clause(&self) -> Option { + pub fn role_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn locking_clauses(&self) -> AstChildren { - support::children(&self.syntax) - } - #[inline] - pub fn offset_clause(&self) -> Option { - support::child(&self.syntax) + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) } #[inline] - pub fn order_by_clause(&self) -> Option { - support::child(&self.syntax) + pub fn by_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BY_KW) } #[inline] - pub fn select_clause(&self) -> Option { - support::child(&self.syntax) + pub fn cascade_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CASCADE_KW) } #[inline] - pub fn where_clause(&self) -> Option { - support::child(&self.syntax) + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) } #[inline] - pub fn window_clause(&self) -> Option { - support::child(&self.syntax) + pub fn from_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FROM_KW) } #[inline] - pub fn with_clause(&self) -> Option { - support::child(&self.syntax) + pub fn grant_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GRANT_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SequenceOption { - pub(crate) syntax: SyntaxNode, -} -impl SequenceOption { #[inline] - pub fn cycle_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CYCLE_KW) + pub fn granted_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GRANTED_KW) } #[inline] - pub fn maxvalue_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MAXVALUE_KW) + pub fn in_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IN_KW) } #[inline] - pub fn minvalue_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::MINVALUE_KW) + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) } #[inline] - pub fn no_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NO_KW) + pub fn option_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPTION_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SequenceOptionList { - pub(crate) syntax: SyntaxNode, -} -impl SequenceOptionList { #[inline] - pub fn sequence_options(&self) -> AstChildren { - support::children(&self.syntax) + pub fn privileges_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PRIVILEGES_KW) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) } #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn revoke_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REVOKE_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Serializable { - pub(crate) syntax: SyntaxNode, -} -impl Serializable { #[inline] - pub fn isolation_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ISOLATION_KW) + pub fn schema_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SCHEMA_KW) } #[inline] - pub fn level_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LEVEL_KW) + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) } #[inline] - pub fn serializable_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SERIALIZABLE_KW) + pub fn tables_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLES_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Set { +pub struct RevokeCommand { pub(crate) syntax: SyntaxNode, } -impl Set { +impl RevokeCommand { #[inline] - pub fn expr(&self) -> Option { + pub fn role(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn path(&self) -> Option { - support::child(&self.syntax) + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) } #[inline] - pub fn eq_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EQ) + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) } #[inline] - pub fn default_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) } #[inline] - pub fn local_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LOCAL_KW) + pub fn delete_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DELETE_KW) } #[inline] - pub fn session_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SESSION_KW) + pub fn execute_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXECUTE_KW) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) } #[inline] - pub fn time_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TIME_KW) + pub fn insert_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INSERT_KW) } #[inline] - pub fn to_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TO_KW) + pub fn references_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REFERENCES_KW) } #[inline] - pub fn zone_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ZONE_KW) + pub fn select_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SELECT_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetAccessMethod { - pub(crate) syntax: SyntaxNode, -} -impl SetAccessMethod { #[inline] - pub fn name_ref(&self) -> Option { - support::child(&self.syntax) + pub fn system_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SYSTEM_KW) } #[inline] - pub fn access_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ACCESS_KW) + pub fn temp_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEMP_KW) } #[inline] - pub fn method_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::METHOD_KW) + pub fn temporary_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEMPORARY_KW) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn trigger_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIGGER_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetClause { - pub(crate) syntax: SyntaxNode, -} -impl SetClause { #[inline] - pub fn set_column_list(&self) -> Option { - support::child(&self.syntax) + pub fn truncate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRUNCATE_KW) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn update_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UPDATE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetColumnList { +pub struct RevokeCommandList { pub(crate) syntax: SyntaxNode, } -impl SetColumnList { +impl RevokeCommandList { #[inline] - pub fn set_columns(&self) -> AstChildren { + pub fn revoke_commands(&self) -> AstChildren { support::children(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetCompression { +pub struct RevokeDefaultPrivileges { pub(crate) syntax: SyntaxNode, } -impl SetCompression { +impl RevokeDefaultPrivileges { #[inline] - pub fn compression_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COMPRESSION_KW) + pub fn privilege_target(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn privileges(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetConfigParam { - pub(crate) syntax: SyntaxNode, -} -impl SetConfigParam { #[inline] - pub fn path(&self) -> Option { + pub fn role_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn cascade_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CASCADE_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetConstraints { - pub(crate) syntax: SyntaxNode, -} -impl SetConstraints { #[inline] - pub fn paths(&self) -> AstChildren { - support::children(&self.syntax) + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) } #[inline] - pub fn all_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ALL_KW) + pub fn from_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FROM_KW) } #[inline] - pub fn constraints_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CONSTRAINTS_KW) + pub fn grant_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GRANT_KW) } #[inline] - pub fn deferred_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFERRED_KW) + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) } #[inline] - pub fn immediate_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IMMEDIATE_KW) + pub fn option_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPTION_KW) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + } + #[inline] + pub fn revoke_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REVOKE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetDefault { +pub struct Role { pub(crate) syntax: SyntaxNode, } -impl SetDefault { +impl Role { #[inline] - pub fn expr(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn default_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + pub fn current_role_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CURRENT_ROLE_KW) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn current_user_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CURRENT_USER_KW) + } + #[inline] + pub fn group_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GROUP_KW) + } + #[inline] + pub fn session_user_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SESSION_USER_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetDefaultColumns { +pub struct RoleList { pub(crate) syntax: SyntaxNode, } -impl SetDefaultColumns { - #[inline] - pub fn column_list(&self) -> Option { - support::child(&self.syntax) - } +impl RoleList { #[inline] - pub fn default_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + pub fn roles(&self) -> AstChildren { + support::children(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RoleOption { + pub(crate) syntax: SyntaxNode, +} +impl RoleOption { #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn inherit_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INHERIT_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetExpr { +pub struct RoleOptionList { pub(crate) syntax: SyntaxNode, } -impl SetExpr { +impl RoleOptionList { #[inline] - pub fn expr(&self) -> Option { - support::child(&self.syntax) + pub fn role_options(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn default_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetExprList { +pub struct Rollback { pub(crate) syntax: SyntaxNode, } -impl SetExprList { +impl Rollback { #[inline] - pub fn set_exprs(&self) -> AstChildren { - support::children(&self.syntax) + pub fn literal(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn abort_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ABORT_KW) } #[inline] - pub fn row_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ROW_KW) + pub fn and_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AND_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetExpression { - pub(crate) syntax: SyntaxNode, -} -impl SetExpression { #[inline] - pub fn expr(&self) -> Option { - support::child(&self.syntax) + pub fn chain_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CHAIN_KW) } #[inline] - pub fn expression_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EXPRESSION_KW) + pub fn no_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NO_KW) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn prepared_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PREPARED_KW) + } + #[inline] + pub fn rollback_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROLLBACK_KW) + } + #[inline] + pub fn savepoint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW) + } + #[inline] + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) + } + #[inline] + pub fn transaction_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRANSACTION_KW) + } + #[inline] + pub fn work_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WORK_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetFuncOption { +pub struct Row { pub(crate) syntax: SyntaxNode, } -impl SetFuncOption { +impl Row { #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn exprs(&self) -> AstChildren { + support::children(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetGenerated { +pub struct RowList { pub(crate) syntax: SyntaxNode, } -impl SetGenerated { +impl RowList { #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn rows(&self) -> AstChildren { + support::children(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetGeneratedOptions { +pub struct RowsFuncOption { pub(crate) syntax: SyntaxNode, } -impl SetGeneratedOptions { - #[inline] - pub fn generated_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::GENERATED_KW) - } +impl RowsFuncOption { #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn rows_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROWS_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetLogged { +pub struct Savepoint { pub(crate) syntax: SyntaxNode, } -impl SetLogged { +impl Savepoint { #[inline] - pub fn logged_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LOGGED_KW) + pub fn name(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn savepoint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetMultipleColumns { +pub struct SchemaAuthorization { pub(crate) syntax: SyntaxNode, } -impl SetMultipleColumns { - #[inline] - pub fn column_list(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn paren_select(&self) -> Option { - support::child(&self.syntax) - } +impl SchemaAuthorization { #[inline] - pub fn set_expr_list(&self) -> Option { + pub fn role(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn eq_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EQ) + pub fn authorization_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetNotNull { +pub struct SecurityFuncOption { pub(crate) syntax: SyntaxNode, } -impl SetNotNull { +impl SecurityFuncOption { #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn definer_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFINER_KW) } #[inline] - pub fn null_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULL_KW) + pub fn invoker_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INVOKER_KW) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn security_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SECURITY_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetNullColumns { +pub struct SecurityLabel { pub(crate) syntax: SyntaxNode, } -impl SetNullColumns { +impl SecurityLabel { #[inline] - pub fn column_list(&self) -> Option { + pub fn aggregate(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn null_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULL_KW) + pub fn for_provider(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn function_sig(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetOptions { - pub(crate) syntax: SyntaxNode, -} -impl SetOptions { #[inline] - pub fn attribute_list(&self) -> Option { + pub fn literal(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn path(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetOptionsList { - pub(crate) syntax: SyntaxNode, -} -impl SetOptionsList { #[inline] - pub fn alter_option_list(&self) -> Option { - support::child(&self.syntax) + pub fn aggregate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AGGREGATE_KW) } #[inline] - pub fn options_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OPTIONS_KW) + pub fn column_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLUMN_KW) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn database_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DATABASE_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetRole { - pub(crate) syntax: SyntaxNode, -} -impl SetRole { #[inline] - pub fn role(&self) -> Option { - support::child(&self.syntax) + pub fn domain_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DOMAIN_KW) } #[inline] - pub fn local_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LOCAL_KW) + pub fn event_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EVENT_KW) } #[inline] - pub fn none_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NONE_KW) + pub fn foreign_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOREIGN_KW) } #[inline] - pub fn reset_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESET_KW) + pub fn function_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FUNCTION_KW) } #[inline] - pub fn role_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ROLE_KW) + pub fn is_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IS_KW) } #[inline] - pub fn session_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SESSION_KW) + pub fn label_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LABEL_KW) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn language_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LANGUAGE_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetSchema { - pub(crate) syntax: SyntaxNode, -} -impl SetSchema { #[inline] - pub fn name_ref(&self) -> Option { - support::child(&self.syntax) + pub fn large_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LARGE_KW) } #[inline] - pub fn schema_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SCHEMA_KW) + pub fn materialized_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn null_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULL_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetSequenceOption { - pub(crate) syntax: SyntaxNode, -} -impl SetSequenceOption { #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn object_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OBJECT_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetSessionAuth { - pub(crate) syntax: SyntaxNode, -} -impl SetSessionAuth { #[inline] - pub fn literal(&self) -> Option { - support::child(&self.syntax) + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) } #[inline] - pub fn role(&self) -> Option { - support::child(&self.syntax) + pub fn procedural_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PROCEDURAL_KW) } #[inline] - pub fn authorization_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW) + pub fn procedure_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PROCEDURE_KW) } #[inline] - pub fn default_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + pub fn publication_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PUBLICATION_KW) } #[inline] - pub fn local_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::LOCAL_KW) + pub fn role_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROLE_KW) } #[inline] - pub fn session_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SESSION_KW) + pub fn routine_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROUTINE_KW) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn schema_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SCHEMA_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetSingleColumn { - pub(crate) syntax: SyntaxNode, -} -impl SetSingleColumn { #[inline] - pub fn column(&self) -> Option { - support::child(&self.syntax) + pub fn security_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SECURITY_KW) } #[inline] - pub fn set_expr(&self) -> Option { - support::child(&self.syntax) + pub fn sequence_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEQUENCE_KW) } #[inline] - pub fn eq_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EQ) + pub fn subscription_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetStatistics { - pub(crate) syntax: SyntaxNode, -} -impl SetStatistics { #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) } #[inline] - pub fn statistics_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::STATISTICS_KW) + pub fn tablespace_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLESPACE_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetStorage { - pub(crate) syntax: SyntaxNode, -} -impl SetStorage { #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn trigger_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIGGER_KW) } #[inline] - pub fn storage_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::STORAGE_KW) + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) + } + #[inline] + pub fn view_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VIEW_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetTablespace { +pub struct Select { pub(crate) syntax: SyntaxNode, } -impl SetTablespace { +impl Select { #[inline] - pub fn path(&self) -> Option { + pub fn fetch_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn filter_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn tablespace_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TABLESPACE_KW) + pub fn from_clause(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetTransaction { - pub(crate) syntax: SyntaxNode, -} -impl SetTransaction { #[inline] - pub fn literal(&self) -> Option { + pub fn group_by_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn transaction_mode_list(&self) -> Option { + pub fn having_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn as_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AS_KW) + pub fn limit_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn characteristics_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CHARACTERISTICS_KW) + pub fn locking_clauses(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn session_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SESSION_KW) + pub fn offset_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn order_by_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn snapshot_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SNAPSHOT_KW) + pub fn select_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn transaction_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TRANSACTION_KW) + pub fn where_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn window_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn with_clause(&self) -> Option { + support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetType { +pub struct SelectClause { pub(crate) syntax: SyntaxNode, } -impl SetType { +impl SelectClause { #[inline] - pub fn collate(&self) -> Option { + pub fn distinct_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn ty(&self) -> Option { + pub fn target_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) } #[inline] - pub fn type_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TYPE_KW) + pub fn select_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SELECT_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetUnlogged { +pub struct SelectInto { pub(crate) syntax: SyntaxNode, } -impl SetUnlogged { +impl SelectInto { #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn filter_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn unlogged_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::UNLOGGED_KW) - } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetWithoutCluster { - pub(crate) syntax: SyntaxNode, -} -impl SetWithoutCluster { - #[inline] - pub fn cluster_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CLUSTER_KW) - } - #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn from_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn without_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITHOUT_KW) + pub fn group_by_clause(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SetWithoutOids { - pub(crate) syntax: SyntaxNode, -} -impl SetWithoutOids { #[inline] - pub fn oids_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OIDS_KW) + pub fn having_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn set_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SET_KW) + pub fn into_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn without_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITHOUT_KW) + pub fn limit_clause(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Show { - pub(crate) syntax: SyntaxNode, -} -impl Show { #[inline] - pub fn show_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SHOW_KW) + pub fn locking_clauses(&self) -> AstChildren { + support::children(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SimilarTo { - pub(crate) syntax: SyntaxNode, -} -impl SimilarTo { #[inline] - pub fn similar_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SIMILAR_KW) + pub fn offset_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn to_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TO_KW) + pub fn order_by_clause(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SliceExpr { - pub(crate) syntax: SyntaxNode, -} -impl SliceExpr { #[inline] - pub fn l_brack_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_BRACK) + pub fn select_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn r_brack_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_BRACK) + pub fn where_clause(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn colon_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::COLON) + pub fn window_clause(&self) -> Option { + support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SortAsc { - pub(crate) syntax: SyntaxNode, -} -impl SortAsc { #[inline] - pub fn asc_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ASC_KW) + pub fn with_clause(&self) -> Option { + support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SortBy { +pub struct SequenceOption { pub(crate) syntax: SyntaxNode, } -impl SortBy { - #[inline] - pub fn expr(&self) -> Option { - support::child(&self.syntax) - } +impl SequenceOption { #[inline] - pub fn nulls_first(&self) -> Option { + pub fn literal(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn nulls_last(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn sort_asc(&self) -> Option { + pub fn path(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn sort_desc(&self) -> Option { + pub fn ty(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn sort_using(&self) -> Option { - support::child(&self.syntax) + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SortByList { - pub(crate) syntax: SyntaxNode, -} -impl SortByList { #[inline] - pub fn sort_bys(&self) -> AstChildren { - support::children(&self.syntax) + pub fn by_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BY_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SortDesc { - pub(crate) syntax: SyntaxNode, -} -impl SortDesc { #[inline] - pub fn desc_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DESC_KW) + pub fn cycle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CYCLE_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SortUsing { - pub(crate) syntax: SyntaxNode, -} -impl SortUsing { #[inline] - pub fn op(&self) -> Option { - support::child(&self.syntax) + pub fn increment_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INCREMENT_KW) } #[inline] - pub fn using_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::USING_KW) + pub fn logged_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LOGGED_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SourceFile { - pub(crate) syntax: SyntaxNode, -} -impl SourceFile { #[inline] - pub fn stmts(&self) -> AstChildren { - support::children(&self.syntax) + pub fn maxvalue_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MAXVALUE_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Storage { - pub(crate) syntax: SyntaxNode, -} -impl Storage { #[inline] - pub fn default_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + pub fn minvalue_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MINVALUE_KW) } #[inline] - pub fn external_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::EXTERNAL_KW) + pub fn name_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NAME_KW) } #[inline] - pub fn ident_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IDENT) + pub fn no_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NO_KW) } #[inline] - pub fn storage_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::STORAGE_KW) + pub fn none_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NONE_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct StrictFuncOption { - pub(crate) syntax: SyntaxNode, -} -impl StrictFuncOption { #[inline] - pub fn called_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CALLED_KW) + pub fn owned_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OWNED_KW) } #[inline] - pub fn input_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INPUT_KW) + pub fn restart_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTART_KW) } #[inline] - pub fn null_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULL_KW) + pub fn sequence_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEQUENCE_KW) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn start_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::START_KW) } #[inline] - pub fn returns_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RETURNS_KW) + pub fn unlogged_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNLOGGED_KW) } #[inline] - pub fn strict_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::STRICT_KW) + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SupportFuncOption { +pub struct SequenceOptionList { pub(crate) syntax: SyntaxNode, } -impl SupportFuncOption { +impl SequenceOptionList { #[inline] - pub fn support_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SUPPORT_KW) + pub fn sequence_options(&self) -> AstChildren { + support::children(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Table { - pub(crate) syntax: SyntaxNode, -} -impl Table { #[inline] - pub fn relation_name(&self) -> Option { - support::child(&self.syntax) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn table_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TABLE_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TableArgList { +pub struct Serializable { pub(crate) syntax: SyntaxNode, } -impl TableArgList { +impl Serializable { #[inline] - pub fn args(&self) -> AstChildren { - support::children(&self.syntax) + pub fn isolation_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ISOLATION_KW) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn level_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LEVEL_KW) } #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn serializable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SERIALIZABLE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TableList { +pub struct Set { pub(crate) syntax: SyntaxNode, } -impl TableList { +impl Set { #[inline] - pub fn relation_names(&self) -> AstChildren { - support::children(&self.syntax) + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn path(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn eq_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EQ) + } + #[inline] + pub fn default_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + } + #[inline] + pub fn local_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LOCAL_KW) + } + #[inline] + pub fn session_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SESSION_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } + #[inline] + pub fn time_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TIME_KW) + } + #[inline] + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) + } + #[inline] + pub fn zone_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ZONE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Tablespace { +pub struct SetAccessMethod { pub(crate) syntax: SyntaxNode, } -impl Tablespace { +impl SetAccessMethod { #[inline] pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn tablespace_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TABLESPACE_KW) + pub fn access_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ACCESS_KW) + } + #[inline] + pub fn method_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::METHOD_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Target { +pub struct SetClause { pub(crate) syntax: SyntaxNode, } -impl Target { - #[inline] - pub fn as_name(&self) -> Option { - support::child(&self.syntax) - } +impl SetClause { #[inline] - pub fn expr(&self) -> Option { + pub fn set_column_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn star_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::STAR) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TargetList { +pub struct SetColumnList { pub(crate) syntax: SyntaxNode, } -impl TargetList { +impl SetColumnList { #[inline] - pub fn targets(&self) -> AstChildren { + pub fn set_columns(&self) -> AstChildren { support::children(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TimeType { +pub struct SetCompression { pub(crate) syntax: SyntaxNode, } -impl TimeType { - #[inline] - pub fn literal(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn timezone(&self) -> Option { - support::child(&self.syntax) - } +impl SetCompression { #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn compression_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMPRESSION_KW) } #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn set_token(&self) -> Option { + 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 time_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TIME_KW) + pub fn path(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn timestamp_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TIMESTAMP_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Timing { +pub struct SetConstraints { pub(crate) syntax: SyntaxNode, } -impl Timing { +impl SetConstraints { #[inline] - pub fn after_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AFTER_KW) + pub fn paths(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn before_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::BEFORE_KW) + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) } #[inline] - pub fn instead_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INSTEAD_KW) + pub fn constraints_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINTS_KW) } #[inline] - pub fn of_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OF_KW) + pub fn deferred_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFERRED_KW) + } + #[inline] + pub fn immediate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IMMEDIATE_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TransactionModeList { +pub struct SetDefault { pub(crate) syntax: SyntaxNode, } -impl TransactionModeList { +impl SetDefault { #[inline] - pub fn transaction_modes(&self) -> AstChildren { - support::children(&self.syntax) + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn default_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TransformFromFunc { +pub struct SetDefaultColumns { pub(crate) syntax: SyntaxNode, } -impl TransformFromFunc { +impl SetDefaultColumns { #[inline] - pub fn function_sig(&self) -> Option { + pub fn column_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn from_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FROM_KW) - } - #[inline] - pub fn function_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FUNCTION_KW) - } - #[inline] - pub fn sql_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SQL_KW) + pub fn default_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULT_KW) } #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TransformFuncOption { +pub struct SetExpr { pub(crate) syntax: SyntaxNode, } -impl TransformFuncOption { +impl SetExpr { #[inline] - pub fn transform_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TRANSFORM_KW) + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn default_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULT_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TransformToFunc { +pub struct SetExprList { pub(crate) syntax: SyntaxNode, } -impl TransformToFunc { - #[inline] - pub fn function_sig(&self) -> Option { - support::child(&self.syntax) - } +impl SetExprList { #[inline] - pub fn function_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FUNCTION_KW) + pub fn set_exprs(&self) -> AstChildren { + support::children(&self.syntax) } #[inline] - pub fn sql_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::SQL_KW) + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) } #[inline] - pub fn to_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TO_KW) + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn row_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROW_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TriggerEvent { +pub struct SetExpression { pub(crate) syntax: SyntaxNode, } -impl TriggerEvent { +impl SetExpression { #[inline] - pub fn trigger_event_update(&self) -> Option { + pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn delete_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DELETE_KW) + pub fn expression_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXPRESSION_KW) } #[inline] - pub fn insert_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INSERT_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetFuncOption { + pub(crate) syntax: SyntaxNode, +} +impl SetFuncOption { #[inline] - pub fn truncate_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TRUNCATE_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TriggerEventList { +pub struct SetGenerated { pub(crate) syntax: SyntaxNode, } -impl TriggerEventList { +impl SetGenerated { #[inline] - pub fn trigger_events(&self) -> AstChildren { - support::children(&self.syntax) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TriggerEventUpdate { +pub struct SetGeneratedOptions { pub(crate) syntax: SyntaxNode, } -impl TriggerEventUpdate { +impl SetGeneratedOptions { #[inline] - pub fn name_refs(&self) -> AstChildren { - support::children(&self.syntax) + pub fn generated_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GENERATED_KW) } #[inline] - pub fn of_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OF_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetLogged { + pub(crate) syntax: SyntaxNode, +} +impl SetLogged { #[inline] - pub fn update_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::UPDATE_KW) + pub fn logged_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LOGGED_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Truncate { +pub struct SetMultipleColumns { pub(crate) syntax: SyntaxNode, } -impl Truncate { +impl SetMultipleColumns { #[inline] - pub fn table_list(&self) -> Option { + pub fn column_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn cascade_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CASCADE_KW) - } - #[inline] - pub fn continue_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CONTINUE_KW) + pub fn paren_select(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn identity_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IDENTITY_KW) + pub fn set_expr_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn restart_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESTART_KW) + pub fn eq_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EQ) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetNotNull { + pub(crate) syntax: SyntaxNode, +} +impl SetNotNull { #[inline] - pub fn restrict_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) } #[inline] - pub fn table_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TABLE_KW) + pub fn null_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULL_KW) } #[inline] - pub fn truncate_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TRUNCATE_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleExpr { +pub struct SetNullColumns { pub(crate) syntax: SyntaxNode, } -impl TupleExpr { +impl SetNullColumns { #[inline] - pub fn exprs(&self) -> AstChildren { - support::children(&self.syntax) + pub fn column_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn null_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULL_KW) } #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UnicodeNormalForm { +pub struct SetOptions { pub(crate) syntax: SyntaxNode, } -impl UnicodeNormalForm { +impl SetOptions { #[inline] - pub fn nfc_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NFC_KW) + pub fn attribute_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn nfd_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NFD_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetOptionsList { + pub(crate) syntax: SyntaxNode, +} +impl SetOptionsList { #[inline] - pub fn nfkc_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NFKC_KW) + pub fn alter_option_list(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn nfkd_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NFKD_KW) + pub fn options_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPTIONS_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UniqueConstraint { +pub struct SetRole { pub(crate) syntax: SyntaxNode, } -impl UniqueConstraint { +impl SetRole { #[inline] - pub fn column_list(&self) -> Option { + pub fn role(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn name(&self) -> Option { - support::child(&self.syntax) + pub fn local_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LOCAL_KW) } #[inline] - pub fn nulls_distinct(&self) -> Option { - support::child(&self.syntax) + pub fn none_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NONE_KW) } #[inline] - pub fn nulls_not_distinct(&self) -> Option { - support::child(&self.syntax) + pub fn reset_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESET_KW) } #[inline] - pub fn using_index(&self) -> Option { - support::child(&self.syntax) + pub fn role_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROLE_KW) } #[inline] - pub fn constraint_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + pub fn session_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SESSION_KW) } #[inline] - pub fn unique_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::UNIQUE_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Unlisten { +pub struct SetSchema { pub(crate) syntax: SyntaxNode, } -impl Unlisten { +impl SetSchema { #[inline] pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn star_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::STAR) + pub fn schema_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SCHEMA_KW) } #[inline] - pub fn unlisten_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::UNLISTEN_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Update { +pub struct SetSequenceOption { pub(crate) syntax: SyntaxNode, } -impl Update { +impl SetSequenceOption { #[inline] - pub fn alias(&self) -> Option { - support::child(&self.syntax) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetSessionAuth { + pub(crate) syntax: SyntaxNode, +} +impl SetSessionAuth { #[inline] - pub fn from_clause(&self) -> Option { + pub fn literal(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn relation_name(&self) -> Option { + pub fn role(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn returning_clause(&self) -> Option { - support::child(&self.syntax) + pub fn authorization_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW) } #[inline] - pub fn set_clause(&self) -> Option { - support::child(&self.syntax) + pub fn default_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULT_KW) } #[inline] - pub fn where_clause(&self) -> Option { - support::child(&self.syntax) + pub fn local_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LOCAL_KW) } #[inline] - pub fn update_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::UPDATE_KW) + pub fn session_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SESSION_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UsingClause { +pub struct SetSingleColumn { pub(crate) syntax: SyntaxNode, } -impl UsingClause { +impl SetSingleColumn { #[inline] - pub fn from_items(&self) -> AstChildren { - support::children(&self.syntax) + pub fn column(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn using_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::USING_KW) + pub fn set_expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn eq_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EQ) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UsingIndex { +pub struct SetStatistics { pub(crate) syntax: SyntaxNode, } -impl UsingIndex { - #[inline] - pub fn name_ref(&self) -> Option { - support::child(&self.syntax) - } +impl SetStatistics { #[inline] - pub fn index_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::INDEX_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } #[inline] - pub fn using_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::USING_KW) + pub fn statistics_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STATISTICS_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UsingMethod { +pub struct SetStorage { pub(crate) syntax: SyntaxNode, } -impl UsingMethod { +impl SetStorage { #[inline] - pub fn name_ref(&self) -> Option { - support::child(&self.syntax) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } #[inline] - pub fn using_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::USING_KW) + pub fn storage_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STORAGE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UsingOnClause { +pub struct SetTablespace { pub(crate) syntax: SyntaxNode, } -impl UsingOnClause { - #[inline] - pub fn expr(&self) -> Option { - support::child(&self.syntax) - } +impl SetTablespace { #[inline] - pub fn from_item(&self) -> Option { + pub fn path(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn on_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ON_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } #[inline] - pub fn using_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::USING_KW) + pub fn tablespace_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLESPACE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Vacuum { +pub struct SetTransaction { pub(crate) syntax: SyntaxNode, } -impl Vacuum { +impl SetTransaction { #[inline] - pub fn relation_name(&self) -> Option { + pub fn literal(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn vacuum_option_list(&self) -> Option { + pub fn transaction_mode_list(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn vacuum_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::VACUUM_KW) + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct VacuumOption { - pub(crate) syntax: SyntaxNode, -} -impl VacuumOption { #[inline] - pub fn full_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FULL_KW) + pub fn characteristics_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CHARACTERISTICS_KW) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct VacuumOptionList { - pub(crate) syntax: SyntaxNode, -} -impl VacuumOptionList { #[inline] - pub fn vacuum_options(&self) -> AstChildren { - support::children(&self.syntax) + pub fn session_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SESSION_KW) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn snapshot_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SNAPSHOT_KW) + } + #[inline] + pub fn transaction_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRANSACTION_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ValidateConstraint { +pub struct SetType { pub(crate) syntax: SyntaxNode, } -impl ValidateConstraint { +impl SetType { #[inline] - pub fn name_ref(&self) -> Option { + pub fn collate(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn constraint_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + pub fn ty(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn validate_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::VALIDATE_KW) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } + #[inline] + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Values { +pub struct SetUnlogged { pub(crate) syntax: SyntaxNode, } -impl Values { +impl SetUnlogged { #[inline] - pub fn row_list(&self) -> Option { - support::child(&self.syntax) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } #[inline] - pub fn values_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::VALUES_KW) + pub fn unlogged_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNLOGGED_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Variant { +pub struct SetWithoutCluster { pub(crate) syntax: SyntaxNode, } -impl Variant { +impl SetWithoutCluster { #[inline] - pub fn literal(&self) -> Option { - support::child(&self.syntax) + pub fn cluster_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CLUSTER_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } + #[inline] + pub fn without_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITHOUT_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct VariantList { +pub struct SetWithoutOids { pub(crate) syntax: SyntaxNode, } -impl VariantList { +impl SetWithoutOids { #[inline] - pub fn variants(&self) -> AstChildren { - support::children(&self.syntax) + pub fn oids_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OIDS_KW) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) } #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn without_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITHOUT_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct VolatilityFuncOption { +pub struct Show { pub(crate) syntax: SyntaxNode, } -impl VolatilityFuncOption { - #[inline] - pub fn immutable_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IMMUTABLE_KW) - } - #[inline] - pub fn stable_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::STABLE_KW) - } +impl Show { #[inline] - pub fn volatile_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::VOLATILE_KW) + pub fn show_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SHOW_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhenClause { +pub struct SimilarTo { pub(crate) syntax: SyntaxNode, } -impl WhenClause { +impl SimilarTo { #[inline] - pub fn then_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::THEN_KW) + pub fn similar_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SIMILAR_KW) } #[inline] - pub fn when_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WHEN_KW) + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhenClauseList { +pub struct SliceExpr { pub(crate) syntax: SyntaxNode, } -impl WhenClauseList { +impl SliceExpr { #[inline] - pub fn when_clause(&self) -> Option { - support::child(&self.syntax) + pub fn l_brack_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_BRACK) } #[inline] - pub fn when_clauses(&self) -> AstChildren { - support::children(&self.syntax) + pub fn r_brack_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_BRACK) + } + #[inline] + pub fn colon_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLON) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhenCondition { +pub struct SomeFn { pub(crate) syntax: SyntaxNode, } -impl WhenCondition { +impl SomeFn { #[inline] pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] + pub fn select_variant(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn l_paren_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::L_PAREN) } @@ -13880,206 +14317,229 @@ impl WhenCondition { support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn when_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WHEN_KW) + pub fn some_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SOME_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhereClause { +pub struct SortAsc { pub(crate) syntax: SyntaxNode, } -impl WhereClause { - #[inline] - pub fn expr(&self) -> Option { - support::child(&self.syntax) - } +impl SortAsc { #[inline] - pub fn where_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WHERE_KW) + pub fn asc_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ASC_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhereCurrentOf { +pub struct SortBy { pub(crate) syntax: SyntaxNode, } -impl WhereCurrentOf { +impl SortBy { #[inline] - pub fn name_ref(&self) -> Option { + pub fn expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn current_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::CURRENT_KW) + pub fn nulls_first(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn of_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OF_KW) + pub fn nulls_last(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn where_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WHERE_KW) + pub fn sort_asc(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn sort_desc(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn sort_using(&self) -> Option { + support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WindowClause { +pub struct SortByList { pub(crate) syntax: SyntaxNode, } -impl WindowClause { +impl SortByList { #[inline] - pub fn window_defs(&self) -> AstChildren { + pub fn sort_bys(&self) -> AstChildren { support::children(&self.syntax) } - #[inline] - pub fn window_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WINDOW_KW) - } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WindowDef { +pub struct SortDesc { pub(crate) syntax: SyntaxNode, } -impl WindowDef { +impl SortDesc { #[inline] - pub fn name(&self) -> Option { - support::child(&self.syntax) + pub fn desc_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DESC_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SortUsing { + pub(crate) syntax: SyntaxNode, +} +impl SortUsing { #[inline] - pub fn window_spec(&self) -> Option { + pub fn op(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) - } - #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) - } - #[inline] - pub fn as_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AS_KW) + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WindowFuncOption { +pub struct SourceFile { pub(crate) syntax: SyntaxNode, } -impl WindowFuncOption { +impl SourceFile { #[inline] - pub fn window_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WINDOW_KW) + pub fn stmts(&self) -> AstChildren { + support::children(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WindowSpec { +pub struct Storage { pub(crate) syntax: SyntaxNode, } -impl WindowSpec { +impl Storage { #[inline] - pub fn exprs(&self) -> AstChildren { - support::children(&self.syntax) + pub fn default_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULT_KW) } #[inline] - pub fn frame_clause(&self) -> Option { - support::child(&self.syntax) + pub fn external_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXTERNAL_KW) } #[inline] - pub fn order_by_clause(&self) -> Option { - support::child(&self.syntax) + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) } #[inline] - pub fn by_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::BY_KW) - } - #[inline] - pub fn ident_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IDENT) - } - #[inline] - pub fn partition_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PARTITION_KW) + pub fn storage_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STORAGE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WithClause { +pub struct StrictFuncOption { pub(crate) syntax: SyntaxNode, } -impl WithClause { +impl StrictFuncOption { #[inline] - pub fn with_tables(&self) -> AstChildren { - support::children(&self.syntax) + pub fn called_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CALLED_KW) } #[inline] - pub fn recursive_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::RECURSIVE_KW) + pub fn input_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INPUT_KW) } #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn null_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULL_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn returns_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RETURNS_KW) + } + #[inline] + pub fn strict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STRICT_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WithData { +pub struct SubstringFn { pub(crate) syntax: SyntaxNode, } -impl WithData { +impl SubstringFn { #[inline] - pub fn data_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DATA_KW) + pub fn expr(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn exprs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) + } + #[inline] + pub fn from_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FROM_KW) + } + #[inline] + pub fn similar_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SIMILAR_KW) + } + #[inline] + pub fn substring_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SUBSTRING_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WithNoData { +pub struct SupportFuncOption { pub(crate) syntax: SyntaxNode, } -impl WithNoData { - #[inline] - pub fn data_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DATA_KW) - } - #[inline] - pub fn no_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NO_KW) - } +impl SupportFuncOption { #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn support_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SUPPORT_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WithOptions { +pub struct Table { pub(crate) syntax: SyntaxNode, } -impl WithOptions { +impl Table { #[inline] - pub fn options_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OPTIONS_KW) + pub fn relation_name(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WithParams { +pub struct TableArgList { pub(crate) syntax: SyntaxNode, } -impl WithParams { +impl TableArgList { + #[inline] + pub fn args(&self) -> AstChildren { + support::children(&self.syntax) + } #[inline] pub fn l_paren_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::L_PAREN) @@ -14088,77 +14548,94 @@ impl WithParams { pub fn r_paren_token(&self) -> Option { support::token(&self.syntax, SyntaxKind::R_PAREN) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TableList { + pub(crate) syntax: SyntaxNode, +} +impl TableList { #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) + pub fn relation_names(&self) -> AstChildren { + support::children(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WithTable { +pub struct TablesampleClause { pub(crate) syntax: SyntaxNode, } -impl WithTable { +impl TablesampleClause { #[inline] - pub fn column_list(&self) -> Option { + pub fn call_expr(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn materialized(&self) -> Option { + pub fn repeatable_clause(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn name(&self) -> Option { - support::child(&self.syntax) + pub fn tablesample_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLESAMPLE_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Tablespace { + pub(crate) syntax: SyntaxNode, +} +impl Tablespace { #[inline] - pub fn not_materialized(&self) -> Option { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn query(&self) -> Option { - support::child(&self.syntax) + pub fn tablespace_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLESPACE_KW) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Target { + pub(crate) syntax: SyntaxNode, +} +impl Target { #[inline] - pub fn l_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::L_PAREN) + pub fn as_name(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn r_paren_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::R_PAREN) + pub fn expr(&self) -> Option { + support::child(&self.syntax) } #[inline] - pub fn as_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::AS_KW) + pub fn star_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STAR) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WithTimezone { +pub struct TargetList { pub(crate) syntax: SyntaxNode, } -impl WithTimezone { - #[inline] - pub fn time_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TIME_KW) - } - #[inline] - pub fn with_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITH_KW) - } +impl TargetList { #[inline] - pub fn zone_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ZONE_KW) + pub fn targets(&self) -> AstChildren { + support::children(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WithinClause { +pub struct TimeType { pub(crate) syntax: SyntaxNode, } -impl WithinClause { +impl TimeType { #[inline] - pub fn order_by_clause(&self) -> Option { + pub fn literal(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn timezone(&self) -> Option { support::child(&self.syntax) } #[inline] @@ -14170,688 +14647,2748 @@ impl WithinClause { support::token(&self.syntax, SyntaxKind::R_PAREN) } #[inline] - pub fn group_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::GROUP_KW) + pub fn time_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TIME_KW) } #[inline] - pub fn within_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITHIN_KW) + pub fn timestamp_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TIMESTAMP_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WithoutOids { +pub struct Timing { pub(crate) syntax: SyntaxNode, } -impl WithoutOids { +impl Timing { #[inline] - pub fn oids_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::OIDS_KW) + pub fn after_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AFTER_KW) } #[inline] - pub fn without_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITHOUT_KW) + pub fn before_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BEFORE_KW) + } + #[inline] + pub fn instead_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INSTEAD_KW) + } + #[inline] + pub fn of_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OF_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WithoutTimezone { +pub struct TransactionModeList { pub(crate) syntax: SyntaxNode, } -impl WithoutTimezone { - #[inline] - pub fn time_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::TIME_KW) - } - #[inline] - pub fn without_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::WITHOUT_KW) - } +impl TransactionModeList { #[inline] - pub fn zone_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ZONE_KW) + pub fn transaction_modes(&self) -> AstChildren { + support::children(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct XmlColumnOption { +pub struct TransformFromFunc { pub(crate) syntax: SyntaxNode, } -impl XmlColumnOption { +impl TransformFromFunc { #[inline] - pub fn expr(&self) -> Option { + pub fn function_sig(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn default_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::DEFAULT_KW) - } - #[inline] - pub fn ident_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::IDENT) + pub fn from_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FROM_KW) } #[inline] - pub fn not_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NOT_KW) + pub fn function_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FUNCTION_KW) } #[inline] - pub fn null_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::NULL_KW) + pub fn sql_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SQL_KW) } #[inline] - pub fn path_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::PATH_KW) + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct XmlColumnOptionList { +pub struct TransformFuncOption { pub(crate) syntax: SyntaxNode, } -impl XmlColumnOptionList { +impl TransformFuncOption { #[inline] - pub fn xml_column_option(&self) -> Option { - support::child(&self.syntax) - } - #[inline] - pub fn xml_column_options(&self) -> AstChildren { - support::children(&self.syntax) + pub fn transform_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRANSFORM_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct XmlTableColumn { +pub struct TransformToFunc { pub(crate) syntax: SyntaxNode, } -impl XmlTableColumn { +impl TransformToFunc { #[inline] - pub fn name(&self) -> Option { + pub fn function_sig(&self) -> Option { support::child(&self.syntax) } #[inline] - pub fn ty(&self) -> Option { - support::child(&self.syntax) + pub fn function_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FUNCTION_KW) } #[inline] - pub fn xml_column_option_list(&self) -> Option { - support::child(&self.syntax) + pub fn sql_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SQL_KW) } #[inline] - pub fn for_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::FOR_KW) + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) } #[inline] - pub fn ordinality_token(&self) -> Option { - support::token(&self.syntax, SyntaxKind::ORDINALITY_KW) + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct XmlTableColumnList { +pub struct TriggerEvent { pub(crate) syntax: SyntaxNode, } -impl XmlTableColumnList { +impl TriggerEvent { #[inline] - pub fn xml_table_columns(&self) -> AstChildren { - support::children(&self.syntax) + pub fn trigger_event_update(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn delete_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DELETE_KW) + } + #[inline] + pub fn insert_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INSERT_KW) + } + #[inline] + pub fn truncate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRUNCATE_KW) } } #[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 TriggerEventList { + pub(crate) syntax: SyntaxNode, } - -#[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), +impl TriggerEventList { + #[inline] + pub fn trigger_events(&self) -> AstChildren { + support::children(&self.syntax) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum AlterMaterializedViewAction { - DependsOnExtension(DependsOnExtension), - NoDependsOnExtension(NoDependsOnExtension), - RenameColumn(RenameColumn), - RenameTo(RenameTo), - SetSchema(SetSchema), - AlterTableAction(AlterTableAction), +pub struct TriggerEventUpdate { + pub(crate) syntax: SyntaxNode, } - -#[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), +impl TriggerEventUpdate { + #[inline] + pub fn name_refs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn of_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OF_KW) + } + #[inline] + pub fn update_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UPDATE_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum ColumnConstraint { - CheckConstraint(CheckConstraint), - DefaultConstraint(DefaultConstraint), - ExcludeConstraint(ExcludeConstraint), - NotNullConstraint(NotNullConstraint), - PrimaryKeyConstraint(PrimaryKeyConstraint), - ReferencesConstraint(ReferencesConstraint), - UniqueConstraint(UniqueConstraint), +pub struct TrimFn { + pub(crate) syntax: SyntaxNode, +} +impl TrimFn { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn exprs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn from_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FROM_KW) + } + #[inline] + pub fn trim_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIM_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum ConflictAction { - ConflictDoNothing(ConflictDoNothing), - ConflictDoUpdateSet(ConflictDoUpdateSet), +pub struct Truncate { + pub(crate) syntax: SyntaxNode, +} +impl Truncate { + #[inline] + pub fn table_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn cascade_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CASCADE_KW) + } + #[inline] + pub fn continue_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONTINUE_KW) + } + #[inline] + pub fn identity_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENTITY_KW) + } + #[inline] + pub fn restart_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTART_KW) + } + #[inline] + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + } + #[inline] + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) + } + #[inline] + pub fn truncate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRUNCATE_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum ConflictTarget { - ConflictOnConstraint(ConflictOnConstraint), - ConflictOnIndex(ConflictOnIndex), +pub struct TupleExpr { + pub(crate) syntax: SyntaxNode, +} +impl TupleExpr { + #[inline] + pub fn exprs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } } #[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 UnicodeNormalForm { + 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 UnicodeNormalForm { + #[inline] + pub fn nfc_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NFC_KW) + } + #[inline] + pub fn nfd_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NFD_KW) + } + #[inline] + pub fn nfkc_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NFKC_KW) + } + #[inline] + pub fn nfkd_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NFKD_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 UniqueConstraint { + 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 UniqueConstraint { + #[inline] + pub fn column_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn nulls_distinct(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn nulls_not_distinct(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn using_index(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + } + #[inline] + pub fn unique_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNIQUE_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum GroupBy { - GroupingCube(GroupingCube), - GroupingExpr(GroupingExpr), - GroupingRollup(GroupingRollup), - GroupingSets(GroupingSets), +pub struct Unlisten { + pub(crate) syntax: SyntaxNode, } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum JoinType { - JoinCross(JoinCross), - JoinFull(JoinFull), - JoinInner(JoinInner), - JoinLeft(JoinLeft), - JoinRight(JoinRight), +impl Unlisten { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn star_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STAR) + } + #[inline] + pub fn unlisten_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNLISTEN_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 Update { + pub(crate) syntax: SyntaxNode, } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum MatchType { - MatchFull(MatchFull), - MatchPartial(MatchPartial), - MatchSimple(MatchSimple), +impl Update { + #[inline] + pub fn alias(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn from_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn relation_name(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn returning_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn set_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn where_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn update_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UPDATE_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum MergeAction { - MergeDelete(MergeDelete), - MergeDoNothing(MergeDoNothing), - MergeInsert(MergeInsert), - MergeUpdate(MergeUpdate), +pub struct UsingClause { + pub(crate) syntax: SyntaxNode, } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum MergeWhenClause { - MergeWhenMatched(MergeWhenMatched), - MergeWhenNotMatchedSource(MergeWhenNotMatchedSource), - MergeWhenNotMatchedTarget(MergeWhenNotMatchedTarget), +impl UsingClause { + #[inline] + pub fn from_items(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum OnCommitAction { - DeleteRows(DeleteRows), - Drop(Drop), - PreserveRows(PreserveRows), +pub struct UsingIndex { + pub(crate) syntax: SyntaxNode, } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum ParamMode { - ParamIn(ParamIn), - ParamInOut(ParamInOut), - ParamOut(ParamOut), - ParamVariadic(ParamVariadic), +impl UsingIndex { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn index_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INDEX_KW) + } + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum PartitionType { - PartitionDefault(PartitionDefault), - PartitionForValuesFrom(PartitionForValuesFrom), - PartitionForValuesIn(PartitionForValuesIn), - PartitionForValuesWith(PartitionForValuesWith), +pub struct UsingMethod { + pub(crate) syntax: SyntaxNode, } - -#[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), +impl UsingMethod { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum RefAction { - Cascade(Cascade), - NoAction(NoAction), - Restrict(Restrict), - SetDefaultColumns(SetDefaultColumns), - SetNullColumns(SetNullColumns), +pub struct UsingOnClause { + pub(crate) syntax: SyntaxNode, } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum SchemaElement { - CreateIndex(CreateIndex), - CreateSequence(CreateSequence), - CreateTable(CreateTable), - CreateTrigger(CreateTrigger), - CreateView(CreateView), - Grant(Grant), +impl UsingOnClause { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn from_item(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum SelectVariant { - CompoundSelect(CompoundSelect), - ParenSelect(ParenSelect), - Select(Select), - SelectInto(SelectInto), - Table(Table), - Values(Values), +pub struct Vacuum { + pub(crate) syntax: SyntaxNode, } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum SetColumn { - SetMultipleColumns(SetMultipleColumns), - SetSingleColumn(SetSingleColumn), +impl Vacuum { + #[inline] + pub fn relation_name(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn vacuum_option_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn vacuum_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VACUUM_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 VacuumOption { + pub(crate) syntax: SyntaxNode, } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum TableArg { - Column(Column), - LikeClause(LikeClause), - TableConstraint(TableConstraint), +impl VacuumOption { + #[inline] + pub fn full_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FULL_KW) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum TableConstraint { - CheckConstraint(CheckConstraint), - ExcludeConstraint(ExcludeConstraint), - ForeignKeyConstraint(ForeignKeyConstraint), - PrimaryKeyConstraint(PrimaryKeyConstraint), - UniqueConstraint(UniqueConstraint), +pub struct VacuumOptionList { + pub(crate) syntax: SyntaxNode, +} +impl VacuumOptionList { + #[inline] + pub fn vacuum_options(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum Timezone { - WithTimezone(WithTimezone), - WithoutTimezone(WithoutTimezone), +pub struct ValidateConstraint { + pub(crate) syntax: SyntaxNode, +} +impl ValidateConstraint { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + } + #[inline] + pub fn validate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VALIDATE_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 Values { + pub(crate) syntax: SyntaxNode, +} +impl Values { + #[inline] + pub fn row_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn values_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VALUES_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Variant { + pub(crate) syntax: SyntaxNode, +} +impl Variant { + #[inline] + pub fn literal(&self) -> Option { + support::child(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct VariantList { + pub(crate) syntax: SyntaxNode, +} +impl VariantList { + #[inline] + pub fn variants(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct VolatilityFuncOption { + pub(crate) syntax: SyntaxNode, +} +impl VolatilityFuncOption { + #[inline] + pub fn immutable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IMMUTABLE_KW) + } + #[inline] + pub fn stable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STABLE_KW) + } + #[inline] + pub fn volatile_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VOLATILE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WhenClause { + pub(crate) syntax: SyntaxNode, +} +impl WhenClause { + #[inline] + pub fn then_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::THEN_KW) + } + #[inline] + pub fn when_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WHEN_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WhenClauseList { + pub(crate) syntax: SyntaxNode, +} +impl WhenClauseList { + #[inline] + pub fn when_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn when_clauses(&self) -> AstChildren { + support::children(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WhenCondition { + pub(crate) syntax: SyntaxNode, +} +impl WhenCondition { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn when_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WHEN_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WhereClause { + pub(crate) syntax: SyntaxNode, +} +impl WhereClause { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn where_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WHERE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WhereConditionClause { + pub(crate) syntax: SyntaxNode, +} +impl WhereConditionClause { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn where_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WHERE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WhereCurrentOf { + pub(crate) syntax: SyntaxNode, +} +impl WhereCurrentOf { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn current_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CURRENT_KW) + } + #[inline] + pub fn of_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OF_KW) + } + #[inline] + pub fn where_token(&self) -> Option { + 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 { + support::children(&self.syntax) + } + #[inline] + pub fn window_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn window_spec(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn as_token(&self) -> Option { + 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 { + 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 { + support::children(&self.syntax) + } + #[inline] + pub fn frame_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn order_by_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn by_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BY_KW) + } + #[inline] + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) + } + #[inline] + pub fn partition_token(&self) -> Option { + 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 { + support::children(&self.syntax) + } + #[inline] + pub fn recursive_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RECURSIVE_KW) + } + #[inline] + pub fn with_token(&self) -> Option { + 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 { + support::token(&self.syntax, SyntaxKind::DATA_KW) + } + #[inline] + pub fn with_token(&self) -> Option { + 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 { + support::token(&self.syntax, SyntaxKind::DATA_KW) + } + #[inline] + pub fn no_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NO_KW) + } + #[inline] + pub fn with_token(&self) -> Option { + 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 { + support::token(&self.syntax, SyntaxKind::OPTIONS_KW) + } + #[inline] + pub fn with_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn with_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn materialized(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn not_materialized(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn query(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn as_token(&self) -> Option { + 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 { + support::token(&self.syntax, SyntaxKind::TIME_KW) + } + #[inline] + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) + } + #[inline] + pub fn zone_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn group_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GROUP_KW) + } + #[inline] + pub fn within_token(&self) -> Option { + 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 { + support::token(&self.syntax, SyntaxKind::OIDS_KW) + } + #[inline] + pub fn without_token(&self) -> Option { + 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 { + support::token(&self.syntax, SyntaxKind::TIME_KW) + } + #[inline] + pub fn without_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITHOUT_KW) + } + #[inline] + pub fn zone_token(&self) -> Option { + 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 { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn default_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + } + #[inline] + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) + } + #[inline] + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) + } + #[inline] + pub fn null_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULL_KW) + } + #[inline] + pub fn path_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn xml_column_options(&self) -> AstChildren { + 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 { + support::children(&self.syntax) + } + #[inline] + pub fn name(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn xml_attribute_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn comma_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMA) + } + #[inline] + pub fn name_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NAME_KW) + } + #[inline] + pub fn xmlattributes_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::XMLATTRIBUTES_KW) + } + #[inline] + pub fn xmlelement_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn xml_passing_mech(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn passing_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PASSING_KW) + } + #[inline] + pub fn xmlexists_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn xmlforest_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn name(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) + } + #[inline] + pub fn default_token(&self) -> Option { + 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 { + support::children(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn content_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONTENT_KW) + } + #[inline] + pub fn document_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DOCUMENT_KW) + } + #[inline] + pub fn preserve_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PRESERVE_KW) + } + #[inline] + pub fn strip_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STRIP_KW) + } + #[inline] + pub fn whitespace_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WHITESPACE_KW) + } + #[inline] + pub fn xmlparse_token(&self) -> Option { + 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 { + support::token(&self.syntax, SyntaxKind::BY_KW) + } + #[inline] + pub fn ref_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REF_KW) + } + #[inline] + pub fn value_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn name(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn comma_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMA) + } + #[inline] + pub fn name_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NAME_KW) + } + #[inline] + pub fn xmlpi_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn comma_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMA) + } + #[inline] + pub fn no_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NO_KW) + } + #[inline] + pub fn standalone_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STANDALONE_KW) + } + #[inline] + pub fn value_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VALUE_KW) + } + #[inline] + pub fn version_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VERSION_KW) + } + #[inline] + pub fn xmlroot_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::XMLROOT_KW) + } + #[inline] + pub fn yes_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn xml_passing_mech(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn passing_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) + } + #[inline] + pub fn content_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONTENT_KW) + } + #[inline] + pub fn document_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DOCUMENT_KW) + } + #[inline] + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) + } + #[inline] + pub fn no_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NO_KW) + } + #[inline] + pub fn xmlserialize_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn xml_row_passing_clause(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn xml_table_column_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn comma_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMA) + } + #[inline] + pub fn xmlnamespaces_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::XMLNAMESPACES_KW) + } + #[inline] + pub fn xmltable_token(&self) -> Option { + 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 { + support::child(&self.syntax) + } + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn xml_column_option_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) + } + #[inline] + pub fn ordinality_token(&self) -> Option { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 AlterSetStatistics { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_SET_STATISTICS + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + 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 AlterStatistics { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_STATISTICS + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + 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 AlterSubscription { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ADD_COLUMN + kind == SyntaxKind::ALTER_SUBSCRIPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -14866,10 +17403,10 @@ impl AstNode for AddColumn { &self.syntax } } -impl AstNode for AddConstraint { +impl AstNode for AlterSystem { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ADD_CONSTRAINT + kind == SyntaxKind::ALTER_SYSTEM } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -14884,10 +17421,10 @@ impl AstNode for AddConstraint { &self.syntax } } -impl AstNode for AddGenerated { +impl AstNode for AlterTable { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ADD_GENERATED + kind == SyntaxKind::ALTER_TABLE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -14902,10 +17439,10 @@ impl AstNode for AddGenerated { &self.syntax } } -impl AstNode for AddOpClassOptions { +impl AstNode for AlterTablespace { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ADD_OP_CLASS_OPTIONS + kind == SyntaxKind::ALTER_TABLESPACE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -14920,10 +17457,10 @@ impl AstNode for AddOpClassOptions { &self.syntax } } -impl AstNode for Aggregate { +impl AstNode for AlterTextSearchConfiguration { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::AGGREGATE + kind == SyntaxKind::ALTER_TEXT_SEARCH_CONFIGURATION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -14938,10 +17475,10 @@ impl AstNode for Aggregate { &self.syntax } } -impl AstNode for Alias { +impl AstNode for AlterTextSearchDictionary { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALIAS + kind == SyntaxKind::ALTER_TEXT_SEARCH_DICTIONARY } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -14956,10 +17493,10 @@ impl AstNode for Alias { &self.syntax } } -impl AstNode for AlterAggregate { +impl AstNode for AlterTextSearchParser { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_AGGREGATE + kind == SyntaxKind::ALTER_TEXT_SEARCH_PARSER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -14974,10 +17511,10 @@ impl AstNode for AlterAggregate { &self.syntax } } -impl AstNode for AlterCollation { +impl AstNode for AlterTextSearchTemplate { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_COLLATION + kind == SyntaxKind::ALTER_TEXT_SEARCH_TEMPLATE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -14992,10 +17529,10 @@ impl AstNode for AlterCollation { &self.syntax } } -impl AstNode for AlterColumn { +impl AstNode for AlterTrigger { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_COLUMN + kind == SyntaxKind::ALTER_TRIGGER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15010,10 +17547,10 @@ impl AstNode for AlterColumn { &self.syntax } } -impl AstNode for AlterConstraint { +impl AstNode for AlterType { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_CONSTRAINT + kind == SyntaxKind::ALTER_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15028,10 +17565,10 @@ impl AstNode for AlterConstraint { &self.syntax } } -impl AstNode for AlterConversion { +impl AstNode for AlterUser { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_CONVERSION + kind == SyntaxKind::ALTER_USER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15046,10 +17583,10 @@ impl AstNode for AlterConversion { &self.syntax } } -impl AstNode for AlterDatabase { +impl AstNode for AlterUserMapping { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_DATABASE + kind == SyntaxKind::ALTER_USER_MAPPING } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15064,10 +17601,10 @@ impl AstNode for AlterDatabase { &self.syntax } } -impl AstNode for AlterDefaultPrivileges { +impl AstNode for AlterView { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_DEFAULT_PRIVILEGES + kind == SyntaxKind::ALTER_VIEW } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15082,10 +17619,10 @@ impl AstNode for AlterDefaultPrivileges { &self.syntax } } -impl AstNode for AlterDomain { +impl AstNode for Analyze { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_DOMAIN + kind == SyntaxKind::ANALYZE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15100,10 +17637,10 @@ impl AstNode for AlterDomain { &self.syntax } } -impl AstNode for AlterEventTrigger { +impl AstNode for AnyFn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_EVENT_TRIGGER + kind == SyntaxKind::ANY_FN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15118,10 +17655,10 @@ impl AstNode for AlterEventTrigger { &self.syntax } } -impl AstNode for AlterExtension { +impl AstNode for Arg { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_EXTENSION + kind == SyntaxKind::ARG } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15136,10 +17673,10 @@ impl AstNode for AlterExtension { &self.syntax } } -impl AstNode for AlterForeignDataWrapper { +impl AstNode for ArgList { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_FOREIGN_DATA_WRAPPER + kind == SyntaxKind::ARG_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15154,10 +17691,10 @@ impl AstNode for AlterForeignDataWrapper { &self.syntax } } -impl AstNode for AlterForeignTable { +impl AstNode for ArrayExpr { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_FOREIGN_TABLE + kind == SyntaxKind::ARRAY_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15172,10 +17709,10 @@ impl AstNode for AlterForeignTable { &self.syntax } } -impl AstNode for AlterFunction { +impl AstNode for ArrayType { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_FUNCTION + kind == SyntaxKind::ARRAY_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15190,10 +17727,10 @@ impl AstNode for AlterFunction { &self.syntax } } -impl AstNode for AlterGroup { +impl AstNode for AsFuncOption { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_GROUP + kind == SyntaxKind::AS_FUNC_OPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15208,10 +17745,10 @@ impl AstNode for AlterGroup { &self.syntax } } -impl AstNode for AlterIndex { +impl AstNode for AsName { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_INDEX + kind == SyntaxKind::AS_NAME } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15226,10 +17763,10 @@ impl AstNode for AlterIndex { &self.syntax } } -impl AstNode for AlterLanguage { +impl AstNode for AtTimeZone { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_LANGUAGE + kind == SyntaxKind::AT_TIME_ZONE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15244,10 +17781,10 @@ impl AstNode for AlterLanguage { &self.syntax } } -impl AstNode for AlterLargeObject { +impl AstNode for AttachPartition { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_LARGE_OBJECT + kind == SyntaxKind::ATTACH_PARTITION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15262,10 +17799,10 @@ impl AstNode for AlterLargeObject { &self.syntax } } -impl AstNode for AlterMaterializedView { +impl AstNode for AttributeList { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_MATERIALIZED_VIEW + kind == SyntaxKind::ATTRIBUTE_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15280,10 +17817,10 @@ impl AstNode for AlterMaterializedView { &self.syntax } } -impl AstNode for AlterOperator { +impl AstNode for AttributeOption { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_OPERATOR + kind == SyntaxKind::ATTRIBUTE_OPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15298,10 +17835,10 @@ impl AstNode for AlterOperator { &self.syntax } } -impl AstNode for AlterOperatorClass { +impl AstNode for AttributeValue { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_OPERATOR_CLASS + kind == SyntaxKind::ATTRIBUTE_VALUE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15316,10 +17853,10 @@ impl AstNode for AlterOperatorClass { &self.syntax } } -impl AstNode for AlterOperatorFamily { +impl AstNode for Begin { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_OPERATOR_FAMILY + kind == SyntaxKind::BEGIN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15334,10 +17871,10 @@ impl AstNode for AlterOperatorFamily { &self.syntax } } -impl AstNode for AlterOption { +impl AstNode for BeginFuncOption { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_OPTION + kind == SyntaxKind::BEGIN_FUNC_OPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15352,10 +17889,10 @@ impl AstNode for AlterOption { &self.syntax } } -impl AstNode for AlterOptionList { +impl AstNode for BetweenExpr { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_OPTION_LIST + kind == SyntaxKind::BETWEEN_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15370,10 +17907,10 @@ impl AstNode for AlterOptionList { &self.syntax } } -impl AstNode for AlterPolicy { +impl AstNode for BinExpr { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_POLICY + kind == SyntaxKind::BIN_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15388,10 +17925,10 @@ impl AstNode for AlterPolicy { &self.syntax } } -impl AstNode for AlterProcedure { +impl AstNode for BitType { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_PROCEDURE + kind == SyntaxKind::BIT_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15406,10 +17943,10 @@ impl AstNode for AlterProcedure { &self.syntax } } -impl AstNode for AlterPublication { +impl AstNode for Call { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_PUBLICATION + kind == SyntaxKind::CALL } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15424,10 +17961,10 @@ impl AstNode for AlterPublication { &self.syntax } } -impl AstNode for AlterRole { +impl AstNode for CallExpr { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_ROLE + kind == SyntaxKind::CALL_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15442,10 +17979,10 @@ impl AstNode for AlterRole { &self.syntax } } -impl AstNode for AlterRoutine { +impl AstNode for Cascade { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_ROUTINE + kind == SyntaxKind::CASCADE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15460,10 +17997,10 @@ impl AstNode for AlterRoutine { &self.syntax } } -impl AstNode for AlterRule { +impl AstNode for CaseExpr { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_RULE + kind == SyntaxKind::CASE_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15478,10 +18015,10 @@ impl AstNode for AlterRule { &self.syntax } } -impl AstNode for AlterSchema { +impl AstNode for CastExpr { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_SCHEMA + kind == SyntaxKind::CAST_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15496,10 +18033,10 @@ impl AstNode for AlterSchema { &self.syntax } } -impl AstNode for AlterSequence { +impl AstNode for CastSig { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_SEQUENCE + kind == SyntaxKind::CAST_SIG } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15514,10 +18051,10 @@ impl AstNode for AlterSequence { &self.syntax } } -impl AstNode for AlterServer { +impl AstNode for CharType { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_SERVER + kind == SyntaxKind::CHAR_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15532,10 +18069,10 @@ impl AstNode for AlterServer { &self.syntax } } -impl AstNode for AlterSetStatistics { +impl AstNode for CheckConstraint { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_SET_STATISTICS + kind == SyntaxKind::CHECK_CONSTRAINT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15550,10 +18087,10 @@ impl AstNode for AlterSetStatistics { &self.syntax } } -impl AstNode for AlterStatistics { +impl AstNode for Checkpoint { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_STATISTICS + kind == SyntaxKind::CHECKPOINT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15568,10 +18105,10 @@ impl AstNode for AlterStatistics { &self.syntax } } -impl AstNode for AlterSubscription { +impl AstNode for Close { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_SUBSCRIPTION + kind == SyntaxKind::CLOSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15586,10 +18123,10 @@ impl AstNode for AlterSubscription { &self.syntax } } -impl AstNode for AlterSystem { +impl AstNode for Cluster { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_SYSTEM + kind == SyntaxKind::CLUSTER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15604,10 +18141,10 @@ impl AstNode for AlterSystem { &self.syntax } } -impl AstNode for AlterTable { +impl AstNode for ClusterOn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_TABLE + kind == SyntaxKind::CLUSTER_ON } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15622,10 +18159,10 @@ impl AstNode for AlterTable { &self.syntax } } -impl AstNode for AlterTablespace { +impl AstNode for Collate { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_TABLESPACE + kind == SyntaxKind::COLLATE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15640,10 +18177,10 @@ impl AstNode for AlterTablespace { &self.syntax } } -impl AstNode for AlterTextSearchConfiguration { +impl AstNode for ColonColon { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_TEXT_SEARCH_CONFIGURATION + kind == SyntaxKind::COLON_COLON } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15658,10 +18195,10 @@ impl AstNode for AlterTextSearchConfiguration { &self.syntax } } -impl AstNode for AlterTextSearchDictionary { +impl AstNode for ColonEq { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_TEXT_SEARCH_DICTIONARY + kind == SyntaxKind::COLON_EQ } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15676,10 +18213,10 @@ impl AstNode for AlterTextSearchDictionary { &self.syntax } } -impl AstNode for AlterTextSearchParser { +impl AstNode for Column { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_TEXT_SEARCH_PARSER + kind == SyntaxKind::COLUMN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15694,10 +18231,10 @@ impl AstNode for AlterTextSearchParser { &self.syntax } } -impl AstNode for AlterTextSearchTemplate { +impl AstNode for ColumnList { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_TEXT_SEARCH_TEMPLATE + kind == SyntaxKind::COLUMN_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15712,10 +18249,10 @@ impl AstNode for AlterTextSearchTemplate { &self.syntax } } -impl AstNode for AlterTrigger { +impl AstNode for CommentOn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_TRIGGER + kind == SyntaxKind::COMMENT_ON } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15730,10 +18267,10 @@ impl AstNode for AlterTrigger { &self.syntax } } -impl AstNode for AlterType { +impl AstNode for Commit { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_TYPE + kind == SyntaxKind::COMMIT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15748,10 +18285,10 @@ impl AstNode for AlterType { &self.syntax } } -impl AstNode for AlterUser { +impl AstNode for CompoundSelect { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_USER + kind == SyntaxKind::COMPOUND_SELECT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15766,10 +18303,10 @@ impl AstNode for AlterUser { &self.syntax } } -impl AstNode for AlterUserMapping { +impl AstNode for CompressionMethod { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_USER_MAPPING + kind == SyntaxKind::COMPRESSION_METHOD } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15784,10 +18321,10 @@ impl AstNode for AlterUserMapping { &self.syntax } } -impl AstNode for AlterView { +impl AstNode for ConflictDoNothing { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ALTER_VIEW + kind == SyntaxKind::CONFLICT_DO_NOTHING } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15802,10 +18339,10 @@ impl AstNode for AlterView { &self.syntax } } -impl AstNode for Analyze { +impl AstNode for ConflictDoUpdateSet { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ANALYZE + kind == SyntaxKind::CONFLICT_DO_UPDATE_SET } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15820,10 +18357,10 @@ impl AstNode for Analyze { &self.syntax } } -impl AstNode for Arg { +impl AstNode for ConflictIndexItem { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ARG + kind == SyntaxKind::CONFLICT_INDEX_ITEM } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15838,10 +18375,10 @@ impl AstNode for Arg { &self.syntax } } -impl AstNode for ArgList { +impl AstNode for ConflictIndexItemList { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ARG_LIST + kind == SyntaxKind::CONFLICT_INDEX_ITEM_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15856,10 +18393,10 @@ impl AstNode for ArgList { &self.syntax } } -impl AstNode for ArrayExpr { +impl AstNode for ConflictOnConstraint { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ARRAY_EXPR + kind == SyntaxKind::CONFLICT_ON_CONSTRAINT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15874,10 +18411,10 @@ impl AstNode for ArrayExpr { &self.syntax } } -impl AstNode for ArrayType { +impl AstNode for ConflictOnIndex { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ARRAY_TYPE + kind == SyntaxKind::CONFLICT_ON_INDEX } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15892,10 +18429,10 @@ impl AstNode for ArrayType { &self.syntax } } -impl AstNode for AsFuncOption { +impl AstNode for ConstraintExclusion { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::AS_FUNC_OPTION + kind == SyntaxKind::CONSTRAINT_EXCLUSION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15910,10 +18447,10 @@ impl AstNode for AsFuncOption { &self.syntax } } -impl AstNode for AsName { +impl AstNode for ConstraintExclusionList { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::AS_NAME + kind == SyntaxKind::CONSTRAINT_EXCLUSION_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15928,10 +18465,10 @@ impl AstNode for AsName { &self.syntax } } -impl AstNode for AtTimeZone { +impl AstNode for ConstraintIncludeClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::AT_TIME_ZONE + kind == SyntaxKind::CONSTRAINT_INCLUDE_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15946,10 +18483,10 @@ impl AstNode for AtTimeZone { &self.syntax } } -impl AstNode for AttachPartition { +impl AstNode for ConstraintIndexMethod { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ATTACH_PARTITION + kind == SyntaxKind::CONSTRAINT_INDEX_METHOD } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15964,10 +18501,10 @@ impl AstNode for AttachPartition { &self.syntax } } -impl AstNode for AttributeList { +impl AstNode for ConstraintIndexTablespace { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ATTRIBUTE_LIST + kind == SyntaxKind::CONSTRAINT_INDEX_TABLESPACE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -15982,10 +18519,10 @@ impl AstNode for AttributeList { &self.syntax } } -impl AstNode for AttributeOption { +impl AstNode for Copy { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ATTRIBUTE_OPTION + kind == SyntaxKind::COPY } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16000,10 +18537,10 @@ impl AstNode for AttributeOption { &self.syntax } } -impl AstNode for AttributeValue { +impl AstNode for CostFuncOption { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ATTRIBUTE_VALUE + kind == SyntaxKind::COST_FUNC_OPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16018,10 +18555,10 @@ impl AstNode for AttributeValue { &self.syntax } } -impl AstNode for Begin { +impl AstNode for CreateAccessMethod { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::BEGIN + kind == SyntaxKind::CREATE_ACCESS_METHOD } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16036,10 +18573,10 @@ impl AstNode for Begin { &self.syntax } } -impl AstNode for BeginFuncOption { +impl AstNode for CreateAggregate { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::BEGIN_FUNC_OPTION + kind == SyntaxKind::CREATE_AGGREGATE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16054,10 +18591,10 @@ impl AstNode for BeginFuncOption { &self.syntax } } -impl AstNode for BetweenExpr { +impl AstNode for CreateCast { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::BETWEEN_EXPR + kind == SyntaxKind::CREATE_CAST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16072,10 +18609,10 @@ impl AstNode for BetweenExpr { &self.syntax } } -impl AstNode for BinExpr { +impl AstNode for CreateCollation { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::BIN_EXPR + kind == SyntaxKind::CREATE_COLLATION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16090,10 +18627,10 @@ impl AstNode for BinExpr { &self.syntax } } -impl AstNode for BitType { +impl AstNode for CreateConversion { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::BIT_TYPE + kind == SyntaxKind::CREATE_CONVERSION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16108,10 +18645,10 @@ impl AstNode for BitType { &self.syntax } } -impl AstNode for Call { +impl AstNode for CreateDatabase { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CALL + kind == SyntaxKind::CREATE_DATABASE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16126,10 +18663,10 @@ impl AstNode for Call { &self.syntax } } -impl AstNode for CallExpr { +impl AstNode for CreateDatabaseOption { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CALL_EXPR + kind == SyntaxKind::CREATE_DATABASE_OPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16144,10 +18681,10 @@ impl AstNode for CallExpr { &self.syntax } } -impl AstNode for Cascade { +impl AstNode for CreateDatabaseOptionList { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CASCADE + kind == SyntaxKind::CREATE_DATABASE_OPTION_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16162,10 +18699,10 @@ impl AstNode for Cascade { &self.syntax } } -impl AstNode for CaseExpr { +impl AstNode for CreateDomain { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CASE_EXPR + kind == SyntaxKind::CREATE_DOMAIN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16180,10 +18717,10 @@ impl AstNode for CaseExpr { &self.syntax } } -impl AstNode for CastExpr { +impl AstNode for CreateEventTrigger { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CAST_EXPR + kind == SyntaxKind::CREATE_EVENT_TRIGGER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16198,10 +18735,10 @@ impl AstNode for CastExpr { &self.syntax } } -impl AstNode for CastSig { +impl AstNode for CreateExtension { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CAST_SIG + kind == SyntaxKind::CREATE_EXTENSION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16216,10 +18753,10 @@ impl AstNode for CastSig { &self.syntax } } -impl AstNode for CharType { +impl AstNode for CreateForeignDataWrapper { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CHAR_TYPE + kind == SyntaxKind::CREATE_FOREIGN_DATA_WRAPPER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16234,10 +18771,10 @@ impl AstNode for CharType { &self.syntax } } -impl AstNode for CheckConstraint { +impl AstNode for CreateForeignTable { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CHECK_CONSTRAINT + kind == SyntaxKind::CREATE_FOREIGN_TABLE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16252,10 +18789,10 @@ impl AstNode for CheckConstraint { &self.syntax } } -impl AstNode for Checkpoint { +impl AstNode for CreateFunction { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CHECKPOINT + kind == SyntaxKind::CREATE_FUNCTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16270,10 +18807,10 @@ impl AstNode for Checkpoint { &self.syntax } } -impl AstNode for Close { +impl AstNode for CreateGroup { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CLOSE + kind == SyntaxKind::CREATE_GROUP } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16288,10 +18825,10 @@ impl AstNode for Close { &self.syntax } } -impl AstNode for Cluster { +impl AstNode for CreateIndex { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CLUSTER + kind == SyntaxKind::CREATE_INDEX } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16306,10 +18843,10 @@ impl AstNode for Cluster { &self.syntax } } -impl AstNode for ClusterOn { +impl AstNode for CreateLanguage { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CLUSTER_ON + kind == SyntaxKind::CREATE_LANGUAGE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16324,10 +18861,10 @@ impl AstNode for ClusterOn { &self.syntax } } -impl AstNode for Collate { +impl AstNode for CreateMaterializedView { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::COLLATE + kind == SyntaxKind::CREATE_MATERIALIZED_VIEW } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16342,10 +18879,10 @@ impl AstNode for Collate { &self.syntax } } -impl AstNode for ColonColon { +impl AstNode for CreateOperator { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::COLON_COLON + kind == SyntaxKind::CREATE_OPERATOR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16360,10 +18897,10 @@ impl AstNode for ColonColon { &self.syntax } } -impl AstNode for ColonEq { +impl AstNode for CreateOperatorClass { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::COLON_EQ + kind == SyntaxKind::CREATE_OPERATOR_CLASS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16378,10 +18915,10 @@ impl AstNode for ColonEq { &self.syntax } } -impl AstNode for Column { +impl AstNode for CreateOperatorFamily { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::COLUMN + kind == SyntaxKind::CREATE_OPERATOR_FAMILY } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16396,10 +18933,10 @@ impl AstNode for Column { &self.syntax } } -impl AstNode for ColumnList { +impl AstNode for CreatePolicy { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::COLUMN_LIST + kind == SyntaxKind::CREATE_POLICY } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16414,10 +18951,10 @@ impl AstNode for ColumnList { &self.syntax } } -impl AstNode for CommentOn { +impl AstNode for CreateProcedure { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::COMMENT_ON + kind == SyntaxKind::CREATE_PROCEDURE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16432,10 +18969,10 @@ impl AstNode for CommentOn { &self.syntax } } -impl AstNode for Commit { +impl AstNode for CreatePublication { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::COMMIT + kind == SyntaxKind::CREATE_PUBLICATION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16450,10 +18987,10 @@ impl AstNode for Commit { &self.syntax } } -impl AstNode for CompoundSelect { +impl AstNode for CreateRole { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::COMPOUND_SELECT + kind == SyntaxKind::CREATE_ROLE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16468,10 +19005,10 @@ impl AstNode for CompoundSelect { &self.syntax } } -impl AstNode for CompressionMethod { +impl AstNode for CreateRule { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::COMPRESSION_METHOD + kind == SyntaxKind::CREATE_RULE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16486,10 +19023,10 @@ impl AstNode for CompressionMethod { &self.syntax } } -impl AstNode for ConflictDoNothing { +impl AstNode for CreateSchema { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONFLICT_DO_NOTHING + kind == SyntaxKind::CREATE_SCHEMA } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16504,10 +19041,10 @@ impl AstNode for ConflictDoNothing { &self.syntax } } -impl AstNode for ConflictDoUpdateSet { +impl AstNode for CreateSequence { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONFLICT_DO_UPDATE_SET + kind == SyntaxKind::CREATE_SEQUENCE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16522,10 +19059,10 @@ impl AstNode for ConflictDoUpdateSet { &self.syntax } } -impl AstNode for ConflictIndexItem { +impl AstNode for CreateServer { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONFLICT_INDEX_ITEM + kind == SyntaxKind::CREATE_SERVER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16540,10 +19077,10 @@ impl AstNode for ConflictIndexItem { &self.syntax } } -impl AstNode for ConflictIndexItemList { +impl AstNode for CreateStatistics { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONFLICT_INDEX_ITEM_LIST + kind == SyntaxKind::CREATE_STATISTICS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16558,10 +19095,10 @@ impl AstNode for ConflictIndexItemList { &self.syntax } } -impl AstNode for ConflictOnConstraint { +impl AstNode for CreateSubscription { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONFLICT_ON_CONSTRAINT + kind == SyntaxKind::CREATE_SUBSCRIPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16576,10 +19113,10 @@ impl AstNode for ConflictOnConstraint { &self.syntax } } -impl AstNode for ConflictOnIndex { +impl AstNode for CreateTable { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONFLICT_ON_INDEX + kind == SyntaxKind::CREATE_TABLE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16594,10 +19131,10 @@ impl AstNode for ConflictOnIndex { &self.syntax } } -impl AstNode for ConstraintExclusion { +impl AstNode for CreateTableAs { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONSTRAINT_EXCLUSION + kind == SyntaxKind::CREATE_TABLE_AS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16612,10 +19149,10 @@ impl AstNode for ConstraintExclusion { &self.syntax } } -impl AstNode for ConstraintExclusionList { +impl AstNode for CreateTablespace { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONSTRAINT_EXCLUSION_LIST + kind == SyntaxKind::CREATE_TABLESPACE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16630,10 +19167,10 @@ impl AstNode for ConstraintExclusionList { &self.syntax } } -impl AstNode for ConstraintIncludeClause { +impl AstNode for CreateTextSearchConfiguration { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONSTRAINT_INCLUDE_CLAUSE + kind == SyntaxKind::CREATE_TEXT_SEARCH_CONFIGURATION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16648,10 +19185,10 @@ impl AstNode for ConstraintIncludeClause { &self.syntax } } -impl AstNode for ConstraintIndexMethod { +impl AstNode for CreateTextSearchDictionary { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONSTRAINT_INDEX_METHOD + kind == SyntaxKind::CREATE_TEXT_SEARCH_DICTIONARY } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16666,10 +19203,10 @@ impl AstNode for ConstraintIndexMethod { &self.syntax } } -impl AstNode for ConstraintIndexTablespace { +impl AstNode for CreateTextSearchParser { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONSTRAINT_INDEX_TABLESPACE + kind == SyntaxKind::CREATE_TEXT_SEARCH_PARSER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16684,10 +19221,10 @@ impl AstNode for ConstraintIndexTablespace { &self.syntax } } -impl AstNode for ConstraintWhereClause { +impl AstNode for CreateTextSearchTemplate { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CONSTRAINT_WHERE_CLAUSE + kind == SyntaxKind::CREATE_TEXT_SEARCH_TEMPLATE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16702,10 +19239,10 @@ impl AstNode for ConstraintWhereClause { &self.syntax } } -impl AstNode for Copy { +impl AstNode for CreateTransform { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::COPY + kind == SyntaxKind::CREATE_TRANSFORM } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16720,10 +19257,10 @@ impl AstNode for Copy { &self.syntax } } -impl AstNode for CostFuncOption { +impl AstNode for CreateTrigger { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::COST_FUNC_OPTION + kind == SyntaxKind::CREATE_TRIGGER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16738,10 +19275,10 @@ impl AstNode for CostFuncOption { &self.syntax } } -impl AstNode for CreateAccessMethod { +impl AstNode for CreateType { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_ACCESS_METHOD + kind == SyntaxKind::CREATE_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16756,10 +19293,10 @@ impl AstNode for CreateAccessMethod { &self.syntax } } -impl AstNode for CreateAggregate { +impl AstNode for CreateUser { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_AGGREGATE + kind == SyntaxKind::CREATE_USER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16774,10 +19311,10 @@ impl AstNode for CreateAggregate { &self.syntax } } -impl AstNode for CreateCast { +impl AstNode for CreateUserMapping { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_CAST + kind == SyntaxKind::CREATE_USER_MAPPING } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16792,10 +19329,10 @@ impl AstNode for CreateCast { &self.syntax } } -impl AstNode for CreateCollation { +impl AstNode for CreateView { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_COLLATION + kind == SyntaxKind::CREATE_VIEW } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16810,10 +19347,10 @@ impl AstNode for CreateCollation { &self.syntax } } -impl AstNode for CreateConversion { +impl AstNode for CustomOp { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_CONVERSION + kind == SyntaxKind::CUSTOM_OP } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16828,10 +19365,10 @@ impl AstNode for CreateConversion { &self.syntax } } -impl AstNode for CreateDatabase { +impl AstNode for Deallocate { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_DATABASE + kind == SyntaxKind::DEALLOCATE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16846,10 +19383,10 @@ impl AstNode for CreateDatabase { &self.syntax } } -impl AstNode for CreateDatabaseOption { +impl AstNode for Declare { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_DATABASE_OPTION + kind == SyntaxKind::DECLARE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16864,10 +19401,10 @@ impl AstNode for CreateDatabaseOption { &self.syntax } } -impl AstNode for CreateDatabaseOptionList { +impl AstNode for DefaultConstraint { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_DATABASE_OPTION_LIST + kind == SyntaxKind::DEFAULT_CONSTRAINT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16882,10 +19419,10 @@ impl AstNode for CreateDatabaseOptionList { &self.syntax } } -impl AstNode for CreateDomain { +impl AstNode for Deferrable { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_DOMAIN + kind == SyntaxKind::DEFERRABLE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16900,10 +19437,10 @@ impl AstNode for CreateDomain { &self.syntax } } -impl AstNode for CreateEventTrigger { +impl AstNode for DeferrableConstraintOption { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_EVENT_TRIGGER + kind == SyntaxKind::DEFERRABLE_CONSTRAINT_OPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16918,10 +19455,10 @@ impl AstNode for CreateEventTrigger { &self.syntax } } -impl AstNode for CreateExtension { +impl AstNode for Delete { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_EXTENSION + kind == SyntaxKind::DELETE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16936,10 +19473,10 @@ impl AstNode for CreateExtension { &self.syntax } } -impl AstNode for CreateForeignDataWrapper { +impl AstNode for DeleteRows { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_FOREIGN_DATA_WRAPPER + kind == SyntaxKind::DELETE_ROWS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16954,10 +19491,10 @@ impl AstNode for CreateForeignDataWrapper { &self.syntax } } -impl AstNode for CreateForeignTable { +impl AstNode for DependsOnExtension { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_FOREIGN_TABLE + kind == SyntaxKind::DEPENDS_ON_EXTENSION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16972,10 +19509,10 @@ impl AstNode for CreateForeignTable { &self.syntax } } -impl AstNode for CreateFunction { +impl AstNode for DetachPartition { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_FUNCTION + kind == SyntaxKind::DETACH_PARTITION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -16990,10 +19527,10 @@ impl AstNode for CreateFunction { &self.syntax } } -impl AstNode for CreateGroup { +impl AstNode for DisableRls { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_GROUP + kind == SyntaxKind::DISABLE_RLS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17008,10 +19545,10 @@ impl AstNode for CreateGroup { &self.syntax } } -impl AstNode for CreateIndex { +impl AstNode for DisableRule { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_INDEX + kind == SyntaxKind::DISABLE_RULE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17026,10 +19563,10 @@ impl AstNode for CreateIndex { &self.syntax } } -impl AstNode for CreateLanguage { +impl AstNode for DisableTrigger { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_LANGUAGE + kind == SyntaxKind::DISABLE_TRIGGER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17044,10 +19581,10 @@ impl AstNode for CreateLanguage { &self.syntax } } -impl AstNode for CreateMaterializedView { +impl AstNode for Discard { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_MATERIALIZED_VIEW + kind == SyntaxKind::DISCARD } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17062,10 +19599,10 @@ impl AstNode for CreateMaterializedView { &self.syntax } } -impl AstNode for CreateOperator { +impl AstNode for DistinctClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_OPERATOR + kind == SyntaxKind::DISTINCT_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17080,10 +19617,10 @@ impl AstNode for CreateOperator { &self.syntax } } -impl AstNode for CreateOperatorClass { +impl AstNode for Do { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_OPERATOR_CLASS + kind == SyntaxKind::DO } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17098,10 +19635,10 @@ impl AstNode for CreateOperatorClass { &self.syntax } } -impl AstNode for CreateOperatorFamily { +impl AstNode for DoubleType { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_OPERATOR_FAMILY + kind == SyntaxKind::DOUBLE_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17116,10 +19653,10 @@ impl AstNode for CreateOperatorFamily { &self.syntax } } -impl AstNode for CreatePolicy { +impl AstNode for Drop { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_POLICY + kind == SyntaxKind::DROP } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17134,10 +19671,10 @@ impl AstNode for CreatePolicy { &self.syntax } } -impl AstNode for CreateProcedure { +impl AstNode for DropAccessMethod { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_PROCEDURE + kind == SyntaxKind::DROP_ACCESS_METHOD } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17152,10 +19689,10 @@ impl AstNode for CreateProcedure { &self.syntax } } -impl AstNode for CreatePublication { +impl AstNode for DropAggregate { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_PUBLICATION + kind == SyntaxKind::DROP_AGGREGATE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17170,10 +19707,10 @@ impl AstNode for CreatePublication { &self.syntax } } -impl AstNode for CreateRole { +impl AstNode for DropCast { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_ROLE + kind == SyntaxKind::DROP_CAST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17188,10 +19725,10 @@ impl AstNode for CreateRole { &self.syntax } } -impl AstNode for CreateRule { +impl AstNode for DropCollation { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_RULE + kind == SyntaxKind::DROP_COLLATION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17206,10 +19743,10 @@ impl AstNode for CreateRule { &self.syntax } } -impl AstNode for CreateSchema { +impl AstNode for DropColumn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_SCHEMA + kind == SyntaxKind::DROP_COLUMN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17224,10 +19761,10 @@ impl AstNode for CreateSchema { &self.syntax } } -impl AstNode for CreateSequence { +impl AstNode for DropConstraint { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_SEQUENCE + kind == SyntaxKind::DROP_CONSTRAINT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17242,10 +19779,10 @@ impl AstNode for CreateSequence { &self.syntax } } -impl AstNode for CreateServer { +impl AstNode for DropConversion { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_SERVER + kind == SyntaxKind::DROP_CONVERSION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17260,10 +19797,10 @@ impl AstNode for CreateServer { &self.syntax } } -impl AstNode for CreateStatistics { +impl AstNode for DropDatabase { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_STATISTICS + kind == SyntaxKind::DROP_DATABASE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17278,10 +19815,10 @@ impl AstNode for CreateStatistics { &self.syntax } } -impl AstNode for CreateSubscription { +impl AstNode for DropDefault { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_SUBSCRIPTION + kind == SyntaxKind::DROP_DEFAULT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17296,10 +19833,10 @@ impl AstNode for CreateSubscription { &self.syntax } } -impl AstNode for CreateTable { +impl AstNode for DropDomain { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_TABLE + kind == SyntaxKind::DROP_DOMAIN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17314,10 +19851,10 @@ impl AstNode for CreateTable { &self.syntax } } -impl AstNode for CreateTableAs { +impl AstNode for DropEventTrigger { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_TABLE_AS + kind == SyntaxKind::DROP_EVENT_TRIGGER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17332,10 +19869,10 @@ impl AstNode for CreateTableAs { &self.syntax } } -impl AstNode for CreateTablespace { +impl AstNode for DropExpression { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_TABLESPACE + kind == SyntaxKind::DROP_EXPRESSION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17350,10 +19887,10 @@ impl AstNode for CreateTablespace { &self.syntax } } -impl AstNode for CreateTextSearchConfiguration { +impl AstNode for DropExtension { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_TEXT_SEARCH_CONFIGURATION + kind == SyntaxKind::DROP_EXTENSION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17368,10 +19905,10 @@ impl AstNode for CreateTextSearchConfiguration { &self.syntax } } -impl AstNode for CreateTextSearchDictionary { +impl AstNode for DropForeignDataWrapper { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_TEXT_SEARCH_DICTIONARY + kind == SyntaxKind::DROP_FOREIGN_DATA_WRAPPER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17386,10 +19923,10 @@ impl AstNode for CreateTextSearchDictionary { &self.syntax } } -impl AstNode for CreateTextSearchParser { +impl AstNode for DropForeignTable { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_TEXT_SEARCH_PARSER + kind == SyntaxKind::DROP_FOREIGN_TABLE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17404,10 +19941,10 @@ impl AstNode for CreateTextSearchParser { &self.syntax } } -impl AstNode for CreateTextSearchTemplate { +impl AstNode for DropFunction { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_TEXT_SEARCH_TEMPLATE + kind == SyntaxKind::DROP_FUNCTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17422,10 +19959,10 @@ impl AstNode for CreateTextSearchTemplate { &self.syntax } } -impl AstNode for CreateTransform { +impl AstNode for DropGroup { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_TRANSFORM + kind == SyntaxKind::DROP_GROUP } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17440,10 +19977,10 @@ impl AstNode for CreateTransform { &self.syntax } } -impl AstNode for CreateTrigger { +impl AstNode for DropIdentity { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_TRIGGER + kind == SyntaxKind::DROP_IDENTITY } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17458,10 +19995,10 @@ impl AstNode for CreateTrigger { &self.syntax } } -impl AstNode for CreateType { +impl AstNode for DropIndex { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_TYPE + kind == SyntaxKind::DROP_INDEX } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17476,10 +20013,10 @@ impl AstNode for CreateType { &self.syntax } } -impl AstNode for CreateUser { +impl AstNode for DropLanguage { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_USER + kind == SyntaxKind::DROP_LANGUAGE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17494,10 +20031,10 @@ impl AstNode for CreateUser { &self.syntax } } -impl AstNode for CreateUserMapping { +impl AstNode for DropMaterializedView { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_USER_MAPPING + kind == SyntaxKind::DROP_MATERIALIZED_VIEW } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17512,10 +20049,10 @@ impl AstNode for CreateUserMapping { &self.syntax } } -impl AstNode for CreateView { +impl AstNode for DropNotNull { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CREATE_VIEW + kind == SyntaxKind::DROP_NOT_NULL } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17530,10 +20067,10 @@ impl AstNode for CreateView { &self.syntax } } -impl AstNode for CustomOp { +impl AstNode for DropOpClassOption { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::CUSTOM_OP + kind == SyntaxKind::DROP_OP_CLASS_OPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17548,10 +20085,10 @@ impl AstNode for CustomOp { &self.syntax } } -impl AstNode for Deallocate { +impl AstNode for DropOpClassOptionList { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DEALLOCATE + kind == SyntaxKind::DROP_OP_CLASS_OPTION_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17566,10 +20103,10 @@ impl AstNode for Deallocate { &self.syntax } } -impl AstNode for Declare { +impl AstNode for DropOpClassOptions { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DECLARE + kind == SyntaxKind::DROP_OP_CLASS_OPTIONS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17584,10 +20121,10 @@ impl AstNode for Declare { &self.syntax } } -impl AstNode for DefaultConstraint { +impl AstNode for DropOperator { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DEFAULT_CONSTRAINT + kind == SyntaxKind::DROP_OPERATOR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17602,10 +20139,10 @@ impl AstNode for DefaultConstraint { &self.syntax } } -impl AstNode for Deferrable { +impl AstNode for DropOperatorClass { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DEFERRABLE + kind == SyntaxKind::DROP_OPERATOR_CLASS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17620,10 +20157,10 @@ impl AstNode for Deferrable { &self.syntax } } -impl AstNode for DeferrableConstraintOption { +impl AstNode for DropOperatorFamily { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DEFERRABLE_CONSTRAINT_OPTION + kind == SyntaxKind::DROP_OPERATOR_FAMILY } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17638,10 +20175,10 @@ impl AstNode for DeferrableConstraintOption { &self.syntax } } -impl AstNode for Delete { +impl AstNode for DropOwned { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DELETE + kind == SyntaxKind::DROP_OWNED } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17656,10 +20193,10 @@ impl AstNode for Delete { &self.syntax } } -impl AstNode for DeleteRows { +impl AstNode for DropPolicy { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DELETE_ROWS + kind == SyntaxKind::DROP_POLICY } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17674,10 +20211,10 @@ impl AstNode for DeleteRows { &self.syntax } } -impl AstNode for DependsOnExtension { +impl AstNode for DropProcedure { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DEPENDS_ON_EXTENSION + kind == SyntaxKind::DROP_PROCEDURE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17692,10 +20229,10 @@ impl AstNode for DependsOnExtension { &self.syntax } } -impl AstNode for DetachPartition { +impl AstNode for DropPublication { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DETACH_PARTITION + kind == SyntaxKind::DROP_PUBLICATION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17710,10 +20247,10 @@ impl AstNode for DetachPartition { &self.syntax } } -impl AstNode for DisableRls { +impl AstNode for DropRole { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DISABLE_RLS + kind == SyntaxKind::DROP_ROLE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17728,10 +20265,10 @@ impl AstNode for DisableRls { &self.syntax } } -impl AstNode for DisableRule { +impl AstNode for DropRoutine { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DISABLE_RULE + kind == SyntaxKind::DROP_ROUTINE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17746,10 +20283,10 @@ impl AstNode for DisableRule { &self.syntax } } -impl AstNode for DisableTrigger { +impl AstNode for DropRule { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DISABLE_TRIGGER + kind == SyntaxKind::DROP_RULE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17764,10 +20301,10 @@ impl AstNode for DisableTrigger { &self.syntax } } -impl AstNode for Discard { +impl AstNode for DropSchema { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DISCARD + kind == SyntaxKind::DROP_SCHEMA } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17782,10 +20319,10 @@ impl AstNode for Discard { &self.syntax } } -impl AstNode for DistinctClause { +impl AstNode for DropSequence { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DISTINCT_CLAUSE + kind == SyntaxKind::DROP_SEQUENCE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17800,10 +20337,10 @@ impl AstNode for DistinctClause { &self.syntax } } -impl AstNode for Do { +impl AstNode for DropServer { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DO + kind == SyntaxKind::DROP_SERVER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17818,10 +20355,10 @@ impl AstNode for Do { &self.syntax } } -impl AstNode for DoubleType { +impl AstNode for DropStatistics { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DOUBLE_TYPE + kind == SyntaxKind::DROP_STATISTICS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17836,10 +20373,10 @@ impl AstNode for DoubleType { &self.syntax } } -impl AstNode for Drop { +impl AstNode for DropSubscription { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP + kind == SyntaxKind::DROP_SUBSCRIPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17854,10 +20391,10 @@ impl AstNode for Drop { &self.syntax } } -impl AstNode for DropAccessMethod { +impl AstNode for DropTable { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_ACCESS_METHOD + kind == SyntaxKind::DROP_TABLE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17872,10 +20409,10 @@ impl AstNode for DropAccessMethod { &self.syntax } } -impl AstNode for DropAggregate { +impl AstNode for DropTablespace { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_AGGREGATE + kind == SyntaxKind::DROP_TABLESPACE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17890,10 +20427,10 @@ impl AstNode for DropAggregate { &self.syntax } } -impl AstNode for DropCast { +impl AstNode for DropTextSearchConfig { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_CAST + kind == SyntaxKind::DROP_TEXT_SEARCH_CONFIG } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17908,10 +20445,10 @@ impl AstNode for DropCast { &self.syntax } } -impl AstNode for DropCollation { +impl AstNode for DropTextSearchDict { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_COLLATION + kind == SyntaxKind::DROP_TEXT_SEARCH_DICT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17926,10 +20463,10 @@ impl AstNode for DropCollation { &self.syntax } } -impl AstNode for DropColumn { +impl AstNode for DropTextSearchParser { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_COLUMN + kind == SyntaxKind::DROP_TEXT_SEARCH_PARSER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17944,10 +20481,10 @@ impl AstNode for DropColumn { &self.syntax } } -impl AstNode for DropConstraint { +impl AstNode for DropTextSearchTemplate { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_CONSTRAINT + kind == SyntaxKind::DROP_TEXT_SEARCH_TEMPLATE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17962,10 +20499,10 @@ impl AstNode for DropConstraint { &self.syntax } } -impl AstNode for DropConversion { +impl AstNode for DropTransform { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_CONVERSION + kind == SyntaxKind::DROP_TRANSFORM } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17980,10 +20517,10 @@ impl AstNode for DropConversion { &self.syntax } } -impl AstNode for DropDatabase { +impl AstNode for DropTrigger { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_DATABASE + kind == SyntaxKind::DROP_TRIGGER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -17998,10 +20535,10 @@ impl AstNode for DropDatabase { &self.syntax } } -impl AstNode for DropDefault { +impl AstNode for DropType { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_DEFAULT + kind == SyntaxKind::DROP_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18016,10 +20553,10 @@ impl AstNode for DropDefault { &self.syntax } } -impl AstNode for DropDomain { +impl AstNode for DropUser { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_DOMAIN + kind == SyntaxKind::DROP_USER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18034,10 +20571,10 @@ impl AstNode for DropDomain { &self.syntax } } -impl AstNode for DropEventTrigger { +impl AstNode for DropUserMapping { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_EVENT_TRIGGER + kind == SyntaxKind::DROP_USER_MAPPING } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18052,10 +20589,10 @@ impl AstNode for DropEventTrigger { &self.syntax } } -impl AstNode for DropExpression { +impl AstNode for DropView { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_EXPRESSION + kind == SyntaxKind::DROP_VIEW } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18070,10 +20607,10 @@ impl AstNode for DropExpression { &self.syntax } } -impl AstNode for DropExtension { +impl AstNode for ElseClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_EXTENSION + kind == SyntaxKind::ELSE_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18088,10 +20625,10 @@ impl AstNode for DropExtension { &self.syntax } } -impl AstNode for DropForeignDataWrapper { +impl AstNode for EnableAlwaysRule { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_FOREIGN_DATA_WRAPPER + kind == SyntaxKind::ENABLE_ALWAYS_RULE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18106,10 +20643,10 @@ impl AstNode for DropForeignDataWrapper { &self.syntax } } -impl AstNode for DropForeignTable { +impl AstNode for EnableAlwaysTrigger { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_FOREIGN_TABLE + kind == SyntaxKind::ENABLE_ALWAYS_TRIGGER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18124,10 +20661,10 @@ impl AstNode for DropForeignTable { &self.syntax } } -impl AstNode for DropFunction { +impl AstNode for EnableReplicaRule { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_FUNCTION + kind == SyntaxKind::ENABLE_REPLICA_RULE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18142,10 +20679,10 @@ impl AstNode for DropFunction { &self.syntax } } -impl AstNode for DropGroup { +impl AstNode for EnableReplicaTrigger { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_GROUP + kind == SyntaxKind::ENABLE_REPLICA_TRIGGER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18160,10 +20697,10 @@ impl AstNode for DropGroup { &self.syntax } } -impl AstNode for DropIdentity { +impl AstNode for EnableRls { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_IDENTITY + kind == SyntaxKind::ENABLE_RLS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18178,10 +20715,10 @@ impl AstNode for DropIdentity { &self.syntax } } -impl AstNode for DropIndex { +impl AstNode for EnableRule { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_INDEX + kind == SyntaxKind::ENABLE_RULE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18196,10 +20733,10 @@ impl AstNode for DropIndex { &self.syntax } } -impl AstNode for DropLanguage { +impl AstNode for EnableTrigger { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_LANGUAGE + kind == SyntaxKind::ENABLE_TRIGGER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18214,10 +20751,10 @@ impl AstNode for DropLanguage { &self.syntax } } -impl AstNode for DropMaterializedView { +impl AstNode for Enforced { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_MATERIALIZED_VIEW + kind == SyntaxKind::ENFORCED } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18232,10 +20769,10 @@ impl AstNode for DropMaterializedView { &self.syntax } } -impl AstNode for DropNotNull { +impl AstNode for EventTriggerWhen { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_NOT_NULL + kind == SyntaxKind::EVENT_TRIGGER_WHEN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18250,10 +20787,10 @@ impl AstNode for DropNotNull { &self.syntax } } -impl AstNode for DropOpClassOption { +impl AstNode for EventTriggerWhenClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_OP_CLASS_OPTION + kind == SyntaxKind::EVENT_TRIGGER_WHEN_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18268,10 +20805,10 @@ impl AstNode for DropOpClassOption { &self.syntax } } -impl AstNode for DropOpClassOptionList { +impl AstNode for ExceptTables { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_OP_CLASS_OPTION_LIST + kind == SyntaxKind::EXCEPT_TABLES } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18286,10 +20823,10 @@ impl AstNode for DropOpClassOptionList { &self.syntax } } -impl AstNode for DropOpClassOptions { +impl AstNode for ExcludeConstraint { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_OP_CLASS_OPTIONS + kind == SyntaxKind::EXCLUDE_CONSTRAINT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18304,10 +20841,10 @@ impl AstNode for DropOpClassOptions { &self.syntax } } -impl AstNode for DropOperator { +impl AstNode for Execute { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_OPERATOR + kind == SyntaxKind::EXECUTE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18322,10 +20859,10 @@ impl AstNode for DropOperator { &self.syntax } } -impl AstNode for DropOperatorClass { +impl AstNode for ExistsFn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_OPERATOR_CLASS + kind == SyntaxKind::EXISTS_FN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18340,10 +20877,10 @@ impl AstNode for DropOperatorClass { &self.syntax } } -impl AstNode for DropOperatorFamily { +impl AstNode for Explain { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_OPERATOR_FAMILY + kind == SyntaxKind::EXPLAIN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18358,10 +20895,10 @@ impl AstNode for DropOperatorFamily { &self.syntax } } -impl AstNode for DropOwned { +impl AstNode for ExprAsName { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_OWNED + kind == SyntaxKind::EXPR_AS_NAME } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18376,10 +20913,10 @@ impl AstNode for DropOwned { &self.syntax } } -impl AstNode for DropPolicy { +impl AstNode for ExprType { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_POLICY + kind == SyntaxKind::EXPR_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18394,10 +20931,10 @@ impl AstNode for DropPolicy { &self.syntax } } -impl AstNode for DropProcedure { +impl AstNode for ExtractFn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_PROCEDURE + kind == SyntaxKind::EXTRACT_FN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18412,10 +20949,10 @@ impl AstNode for DropProcedure { &self.syntax } } -impl AstNode for DropPublication { +impl AstNode for FatArrow { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_PUBLICATION + kind == SyntaxKind::FAT_ARROW } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18430,10 +20967,10 @@ impl AstNode for DropPublication { &self.syntax } } -impl AstNode for DropRole { +impl AstNode for FdwOption { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_ROLE + kind == SyntaxKind::FDW_OPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18448,10 +20985,10 @@ impl AstNode for DropRole { &self.syntax } } -impl AstNode for DropRoutine { +impl AstNode for FdwOptionList { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_ROUTINE + kind == SyntaxKind::FDW_OPTION_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18466,10 +21003,10 @@ impl AstNode for DropRoutine { &self.syntax } } -impl AstNode for DropRule { +impl AstNode for Fetch { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_RULE + kind == SyntaxKind::FETCH } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18484,10 +21021,10 @@ impl AstNode for DropRule { &self.syntax } } -impl AstNode for DropSchema { +impl AstNode for FetchClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_SCHEMA + kind == SyntaxKind::FETCH_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18502,10 +21039,10 @@ impl AstNode for DropSchema { &self.syntax } } -impl AstNode for DropSequence { +impl AstNode for FieldExpr { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_SEQUENCE + kind == SyntaxKind::FIELD_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18520,10 +21057,10 @@ impl AstNode for DropSequence { &self.syntax } } -impl AstNode for DropServer { +impl AstNode for FilterClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_SERVER + kind == SyntaxKind::FILTER_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18538,10 +21075,10 @@ impl AstNode for DropServer { &self.syntax } } -impl AstNode for DropStatistics { +impl AstNode for ForProvider { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_STATISTICS + kind == SyntaxKind::FOR_PROVIDER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18556,10 +21093,10 @@ impl AstNode for DropStatistics { &self.syntax } } -impl AstNode for DropSubscription { +impl AstNode for ForceRls { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_SUBSCRIPTION + kind == SyntaxKind::FORCE_RLS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18574,10 +21111,10 @@ impl AstNode for DropSubscription { &self.syntax } } -impl AstNode for DropTable { +impl AstNode for ForeignKeyConstraint { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_TABLE + kind == SyntaxKind::FOREIGN_KEY_CONSTRAINT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18592,10 +21129,10 @@ impl AstNode for DropTable { &self.syntax } } -impl AstNode for DropTablespace { +impl AstNode for FrameClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_TABLESPACE + kind == SyntaxKind::FRAME_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18610,10 +21147,10 @@ impl AstNode for DropTablespace { &self.syntax } } -impl AstNode for DropTextSearchConfig { +impl AstNode for FromClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_TEXT_SEARCH_CONFIG + kind == SyntaxKind::FROM_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18628,10 +21165,10 @@ impl AstNode for DropTextSearchConfig { &self.syntax } } -impl AstNode for DropTextSearchDict { +impl AstNode for FromItem { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_TEXT_SEARCH_DICT + kind == SyntaxKind::FROM_ITEM } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18646,10 +21183,10 @@ impl AstNode for DropTextSearchDict { &self.syntax } } -impl AstNode for DropTextSearchParser { +impl AstNode for FromServer { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_TEXT_SEARCH_PARSER + kind == SyntaxKind::FROM_SERVER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18664,10 +21201,10 @@ impl AstNode for DropTextSearchParser { &self.syntax } } -impl AstNode for DropTextSearchTemplate { +impl AstNode for FromTable { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_TEXT_SEARCH_TEMPLATE + kind == SyntaxKind::FROM_TABLE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18682,10 +21219,10 @@ impl AstNode for DropTextSearchTemplate { &self.syntax } } -impl AstNode for DropTransform { +impl AstNode for FuncOptionList { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_TRANSFORM + kind == SyntaxKind::FUNC_OPTION_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18700,10 +21237,10 @@ impl AstNode for DropTransform { &self.syntax } } -impl AstNode for DropTrigger { +impl AstNode for FunctionSig { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_TRIGGER + kind == SyntaxKind::FUNCTION_SIG } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18718,10 +21255,10 @@ impl AstNode for DropTrigger { &self.syntax } } -impl AstNode for DropType { +impl AstNode for FunctionSigList { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_TYPE + kind == SyntaxKind::FUNCTION_SIG_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18736,10 +21273,10 @@ impl AstNode for DropType { &self.syntax } } -impl AstNode for DropUser { +impl AstNode for GeneratedConstraint { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_USER + kind == SyntaxKind::GENERATED_CONSTRAINT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18754,10 +21291,10 @@ impl AstNode for DropUser { &self.syntax } } -impl AstNode for DropUserMapping { +impl AstNode for Grant { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_USER_MAPPING + kind == SyntaxKind::GRANT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18772,10 +21309,10 @@ impl AstNode for DropUserMapping { &self.syntax } } -impl AstNode for DropView { +impl AstNode for GrantDefaultPrivileges { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::DROP_VIEW + kind == SyntaxKind::GRANT_DEFAULT_PRIVILEGES } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18790,10 +21327,10 @@ impl AstNode for DropView { &self.syntax } } -impl AstNode for ElseClause { +impl AstNode for GroupByClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ELSE_CLAUSE + kind == SyntaxKind::GROUP_BY_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18808,10 +21345,10 @@ impl AstNode for ElseClause { &self.syntax } } -impl AstNode for EnableAlwaysRule { +impl AstNode for GroupByList { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ENABLE_ALWAYS_RULE + kind == SyntaxKind::GROUP_BY_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18826,10 +21363,10 @@ impl AstNode for EnableAlwaysRule { &self.syntax } } -impl AstNode for EnableAlwaysTrigger { +impl AstNode for GroupingCube { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ENABLE_ALWAYS_TRIGGER + kind == SyntaxKind::GROUPING_CUBE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18844,10 +21381,10 @@ impl AstNode for EnableAlwaysTrigger { &self.syntax } } -impl AstNode for EnableReplicaRule { +impl AstNode for GroupingExpr { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ENABLE_REPLICA_RULE + kind == SyntaxKind::GROUPING_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18862,10 +21399,10 @@ impl AstNode for EnableReplicaRule { &self.syntax } } -impl AstNode for EnableReplicaTrigger { +impl AstNode for GroupingRollup { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ENABLE_REPLICA_TRIGGER + kind == SyntaxKind::GROUPING_ROLLUP } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18880,10 +21417,10 @@ impl AstNode for EnableReplicaTrigger { &self.syntax } } -impl AstNode for EnableRls { +impl AstNode for GroupingSets { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ENABLE_RLS + kind == SyntaxKind::GROUPING_SETS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18898,10 +21435,10 @@ impl AstNode for EnableRls { &self.syntax } } -impl AstNode for EnableRule { +impl AstNode for Gteq { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ENABLE_RULE + kind == SyntaxKind::GTEQ } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18916,10 +21453,10 @@ impl AstNode for EnableRule { &self.syntax } } -impl AstNode for EnableTrigger { +impl AstNode for HandlerClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ENABLE_TRIGGER + kind == SyntaxKind::HANDLER_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18934,10 +21471,10 @@ impl AstNode for EnableTrigger { &self.syntax } } -impl AstNode for Enforced { +impl AstNode for HavingClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::ENFORCED + kind == SyntaxKind::HAVING_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18952,10 +21489,10 @@ impl AstNode for Enforced { &self.syntax } } -impl AstNode for EventTriggerWhen { +impl AstNode for IfExists { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::EVENT_TRIGGER_WHEN + kind == SyntaxKind::IF_EXISTS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18970,10 +21507,10 @@ impl AstNode for EventTriggerWhen { &self.syntax } } -impl AstNode for EventTriggerWhenClause { +impl AstNode for IfNotExists { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::EVENT_TRIGGER_WHEN_CLAUSE + kind == SyntaxKind::IF_NOT_EXISTS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -18988,10 +21525,10 @@ impl AstNode for EventTriggerWhenClause { &self.syntax } } -impl AstNode for ExceptTables { +impl AstNode for ImportForeignSchema { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::EXCEPT_TABLES + kind == SyntaxKind::IMPORT_FOREIGN_SCHEMA } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19006,10 +21543,10 @@ impl AstNode for ExceptTables { &self.syntax } } -impl AstNode for ExcludeConstraint { +impl AstNode for IndexExpr { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::EXCLUDE_CONSTRAINT + kind == SyntaxKind::INDEX_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19024,10 +21561,10 @@ impl AstNode for ExcludeConstraint { &self.syntax } } -impl AstNode for Execute { +impl AstNode for Inherit { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::EXECUTE + kind == SyntaxKind::INHERIT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19042,10 +21579,10 @@ impl AstNode for Execute { &self.syntax } } -impl AstNode for Explain { +impl AstNode for InheritTable { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::EXPLAIN + kind == SyntaxKind::INHERIT_TABLE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19060,10 +21597,10 @@ impl AstNode for Explain { &self.syntax } } -impl AstNode for ExprType { +impl AstNode for Inherits { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::EXPR_TYPE + kind == SyntaxKind::INHERITS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19078,10 +21615,10 @@ impl AstNode for ExprType { &self.syntax } } -impl AstNode for FatArrow { +impl AstNode for InitiallyDeferredConstraintOption { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FAT_ARROW + kind == SyntaxKind::INITIALLY_DEFERRED_CONSTRAINT_OPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19096,10 +21633,10 @@ impl AstNode for FatArrow { &self.syntax } } -impl AstNode for FdwOption { +impl AstNode for InitiallyImmediateConstraintOption { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FDW_OPTION + kind == SyntaxKind::INITIALLY_IMMEDIATE_CONSTRAINT_OPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19114,10 +21651,10 @@ impl AstNode for FdwOption { &self.syntax } } -impl AstNode for FdwOptionList { +impl AstNode for Insert { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FDW_OPTION_LIST + kind == SyntaxKind::INSERT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19132,10 +21669,10 @@ impl AstNode for FdwOptionList { &self.syntax } } -impl AstNode for Fetch { +impl AstNode for IntervalType { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FETCH + kind == SyntaxKind::INTERVAL_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19150,10 +21687,10 @@ impl AstNode for Fetch { &self.syntax } } -impl AstNode for FetchClause { +impl AstNode for IntoClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FETCH_CLAUSE + kind == SyntaxKind::INTO_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19168,10 +21705,10 @@ impl AstNode for FetchClause { &self.syntax } } -impl AstNode for FieldExpr { +impl AstNode for IntoSchema { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FIELD_EXPR + kind == SyntaxKind::INTO_SCHEMA } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19186,10 +21723,10 @@ impl AstNode for FieldExpr { &self.syntax } } -impl AstNode for FilterClause { +impl AstNode for IsDistinctFrom { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FILTER_CLAUSE + kind == SyntaxKind::IS_DISTINCT_FROM } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19204,10 +21741,10 @@ impl AstNode for FilterClause { &self.syntax } } -impl AstNode for ForProvider { +impl AstNode for IsJson { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FOR_PROVIDER + kind == SyntaxKind::IS_JSON } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19222,10 +21759,10 @@ impl AstNode for ForProvider { &self.syntax } } -impl AstNode for ForceRls { +impl AstNode for IsJsonArray { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FORCE_RLS + kind == SyntaxKind::IS_JSON_ARRAY } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19240,10 +21777,10 @@ impl AstNode for ForceRls { &self.syntax } } -impl AstNode for ForeignKeyConstraint { +impl AstNode for IsJsonObject { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FOREIGN_KEY_CONSTRAINT + kind == SyntaxKind::IS_JSON_OBJECT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19258,10 +21795,10 @@ impl AstNode for ForeignKeyConstraint { &self.syntax } } -impl AstNode for FrameClause { +impl AstNode for IsJsonScalar { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FRAME_CLAUSE + kind == SyntaxKind::IS_JSON_SCALAR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19276,10 +21813,10 @@ impl AstNode for FrameClause { &self.syntax } } -impl AstNode for FromClause { +impl AstNode for IsJsonValue { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FROM_CLAUSE + kind == SyntaxKind::IS_JSON_VALUE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19294,10 +21831,10 @@ impl AstNode for FromClause { &self.syntax } } -impl AstNode for FromItem { +impl AstNode for IsNormalized { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FROM_ITEM + kind == SyntaxKind::IS_NORMALIZED } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19312,10 +21849,10 @@ impl AstNode for FromItem { &self.syntax } } -impl AstNode for FromServer { +impl AstNode for IsNot { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FROM_SERVER + kind == SyntaxKind::IS_NOT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19330,10 +21867,10 @@ impl AstNode for FromServer { &self.syntax } } -impl AstNode for FromTable { +impl AstNode for IsNotDistinctFrom { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FROM_TABLE + kind == SyntaxKind::IS_NOT_DISTINCT_FROM } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19348,10 +21885,10 @@ impl AstNode for FromTable { &self.syntax } } -impl AstNode for FuncOptionList { +impl AstNode for IsNotJson { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FUNC_OPTION_LIST + kind == SyntaxKind::IS_NOT_JSON } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19366,10 +21903,10 @@ impl AstNode for FuncOptionList { &self.syntax } } -impl AstNode for FunctionSig { +impl AstNode for IsNotJsonArray { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FUNCTION_SIG + kind == SyntaxKind::IS_NOT_JSON_ARRAY } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19384,10 +21921,10 @@ impl AstNode for FunctionSig { &self.syntax } } -impl AstNode for FunctionSigList { +impl AstNode for IsNotJsonObject { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::FUNCTION_SIG_LIST + kind == SyntaxKind::IS_NOT_JSON_OBJECT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19402,10 +21939,10 @@ impl AstNode for FunctionSigList { &self.syntax } } -impl AstNode for GeneratedConstraint { +impl AstNode for IsNotJsonScalar { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::GENERATED_CONSTRAINT + kind == SyntaxKind::IS_NOT_JSON_SCALAR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19420,10 +21957,10 @@ impl AstNode for GeneratedConstraint { &self.syntax } } -impl AstNode for Grant { +impl AstNode for IsNotJsonValue { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::GRANT + kind == SyntaxKind::IS_NOT_JSON_VALUE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19438,10 +21975,10 @@ impl AstNode for Grant { &self.syntax } } -impl AstNode for GrantDefaultPrivileges { +impl AstNode for IsNotNormalized { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::GRANT_DEFAULT_PRIVILEGES + kind == SyntaxKind::IS_NOT_NORMALIZED } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19456,10 +21993,10 @@ impl AstNode for GrantDefaultPrivileges { &self.syntax } } -impl AstNode for GroupByClause { +impl AstNode for Join { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::GROUP_BY_CLAUSE + kind == SyntaxKind::JOIN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19474,10 +22011,10 @@ impl AstNode for GroupByClause { &self.syntax } } -impl AstNode for GroupByList { +impl AstNode for JoinCross { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::GROUP_BY_LIST + kind == SyntaxKind::JOIN_CROSS } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19492,10 +22029,10 @@ impl AstNode for GroupByList { &self.syntax } } -impl AstNode for GroupingCube { +impl AstNode for JoinExpr { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::GROUPING_CUBE + kind == SyntaxKind::JOIN_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19510,10 +22047,10 @@ impl AstNode for GroupingCube { &self.syntax } } -impl AstNode for GroupingExpr { +impl AstNode for JoinFull { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::GROUPING_EXPR + kind == SyntaxKind::JOIN_FULL } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19528,10 +22065,10 @@ impl AstNode for GroupingExpr { &self.syntax } } -impl AstNode for GroupingRollup { +impl AstNode for JoinInner { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::GROUPING_ROLLUP + kind == SyntaxKind::JOIN_INNER } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19546,10 +22083,10 @@ impl AstNode for GroupingRollup { &self.syntax } } -impl AstNode for GroupingSets { +impl AstNode for JoinLeft { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::GROUPING_SETS + kind == SyntaxKind::JOIN_LEFT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19564,10 +22101,10 @@ impl AstNode for GroupingSets { &self.syntax } } -impl AstNode for Gteq { +impl AstNode for JoinRight { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::GTEQ + kind == SyntaxKind::JOIN_RIGHT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19582,10 +22119,10 @@ impl AstNode for Gteq { &self.syntax } } -impl AstNode for HandlerClause { +impl AstNode for JoinUsingClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::HANDLER_CLAUSE + kind == SyntaxKind::JOIN_USING_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19600,10 +22137,10 @@ impl AstNode for HandlerClause { &self.syntax } } -impl AstNode for HavingClause { +impl AstNode for JsonArrayAggFn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::HAVING_CLAUSE + kind == SyntaxKind::JSON_ARRAY_AGG_FN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19618,10 +22155,10 @@ impl AstNode for HavingClause { &self.syntax } } -impl AstNode for IfExists { +impl AstNode for JsonArrayFn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IF_EXISTS + kind == SyntaxKind::JSON_ARRAY_FN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19636,10 +22173,10 @@ impl AstNode for IfExists { &self.syntax } } -impl AstNode for IfNotExists { +impl AstNode for JsonBehaviorClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IF_NOT_EXISTS + kind == SyntaxKind::JSON_BEHAVIOR_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19654,10 +22191,10 @@ impl AstNode for IfNotExists { &self.syntax } } -impl AstNode for ImportForeignSchema { +impl AstNode for JsonBehaviorDefault { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IMPORT_FOREIGN_SCHEMA + kind == SyntaxKind::JSON_BEHAVIOR_DEFAULT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19672,10 +22209,10 @@ impl AstNode for ImportForeignSchema { &self.syntax } } -impl AstNode for IndexExpr { +impl AstNode for JsonBehaviorEmptyArray { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::INDEX_EXPR + kind == SyntaxKind::JSON_BEHAVIOR_EMPTY_ARRAY } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19690,10 +22227,10 @@ impl AstNode for IndexExpr { &self.syntax } } -impl AstNode for Inherit { +impl AstNode for JsonBehaviorEmptyObject { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::INHERIT + kind == SyntaxKind::JSON_BEHAVIOR_EMPTY_OBJECT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19708,10 +22245,10 @@ impl AstNode for Inherit { &self.syntax } } -impl AstNode for InheritTable { +impl AstNode for JsonBehaviorError { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::INHERIT_TABLE + kind == SyntaxKind::JSON_BEHAVIOR_ERROR } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19726,10 +22263,10 @@ impl AstNode for InheritTable { &self.syntax } } -impl AstNode for Inherits { +impl AstNode for JsonBehaviorFalse { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::INHERITS + kind == SyntaxKind::JSON_BEHAVIOR_FALSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19744,10 +22281,10 @@ impl AstNode for Inherits { &self.syntax } } -impl AstNode for InitiallyDeferredConstraintOption { +impl AstNode for JsonBehaviorNull { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::INITIALLY_DEFERRED_CONSTRAINT_OPTION + kind == SyntaxKind::JSON_BEHAVIOR_NULL } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19762,10 +22299,10 @@ impl AstNode for InitiallyDeferredConstraintOption { &self.syntax } } -impl AstNode for InitiallyImmediateConstraintOption { +impl AstNode for JsonBehaviorTrue { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::INITIALLY_IMMEDIATE_CONSTRAINT_OPTION + kind == SyntaxKind::JSON_BEHAVIOR_TRUE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19780,10 +22317,10 @@ impl AstNode for InitiallyImmediateConstraintOption { &self.syntax } } -impl AstNode for Insert { +impl AstNode for JsonBehaviorUnknown { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::INSERT + kind == SyntaxKind::JSON_BEHAVIOR_UNKNOWN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19798,10 +22335,10 @@ impl AstNode for Insert { &self.syntax } } -impl AstNode for IntervalType { +impl AstNode for JsonEncodingClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::INTERVAL_TYPE + kind == SyntaxKind::JSON_ENCODING_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19816,10 +22353,10 @@ impl AstNode for IntervalType { &self.syntax } } -impl AstNode for IntoClause { +impl AstNode for JsonExistsFn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::INTO_CLAUSE + kind == SyntaxKind::JSON_EXISTS_FN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19834,10 +22371,10 @@ impl AstNode for IntoClause { &self.syntax } } -impl AstNode for IntoSchema { +impl AstNode for JsonExprFormat { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::INTO_SCHEMA + kind == SyntaxKind::JSON_EXPR_FORMAT } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19852,10 +22389,10 @@ impl AstNode for IntoSchema { &self.syntax } } -impl AstNode for IsDistinctFrom { +impl AstNode for JsonFn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_DISTINCT_FROM + kind == SyntaxKind::JSON_FN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19870,10 +22407,10 @@ impl AstNode for IsDistinctFrom { &self.syntax } } -impl AstNode for IsJson { +impl AstNode for JsonFormatClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_JSON + kind == SyntaxKind::JSON_FORMAT_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19888,10 +22425,10 @@ impl AstNode for IsJson { &self.syntax } } -impl AstNode for IsJsonArray { +impl AstNode for JsonKeyValue { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_JSON_ARRAY + kind == SyntaxKind::JSON_KEY_VALUE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19906,10 +22443,10 @@ impl AstNode for IsJsonArray { &self.syntax } } -impl AstNode for IsJsonObject { +impl AstNode for JsonKeysUniqueClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_JSON_OBJECT + kind == SyntaxKind::JSON_KEYS_UNIQUE_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19924,10 +22461,10 @@ impl AstNode for IsJsonObject { &self.syntax } } -impl AstNode for IsJsonScalar { +impl AstNode for JsonNullClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_JSON_SCALAR + kind == SyntaxKind::JSON_NULL_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19942,10 +22479,10 @@ impl AstNode for IsJsonScalar { &self.syntax } } -impl AstNode for IsJsonValue { +impl AstNode for JsonObjectAggFn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_JSON_VALUE + kind == SyntaxKind::JSON_OBJECT_AGG_FN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19960,10 +22497,10 @@ impl AstNode for IsJsonValue { &self.syntax } } -impl AstNode for IsNormalized { +impl AstNode for JsonObjectFn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_NORMALIZED + kind == SyntaxKind::JSON_OBJECT_FN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19978,10 +22515,10 @@ impl AstNode for IsNormalized { &self.syntax } } -impl AstNode for IsNot { +impl AstNode for JsonOnEmptyClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_NOT + kind == SyntaxKind::JSON_ON_EMPTY_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -19996,10 +22533,10 @@ impl AstNode for IsNot { &self.syntax } } -impl AstNode for IsNotDistinctFrom { +impl AstNode for JsonOnErrorClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_NOT_DISTINCT_FROM + kind == SyntaxKind::JSON_ON_ERROR_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -20014,10 +22551,10 @@ impl AstNode for IsNotDistinctFrom { &self.syntax } } -impl AstNode for IsNotJson { +impl AstNode for JsonPassingArg { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_NOT_JSON + kind == SyntaxKind::JSON_PASSING_ARG } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -20032,10 +22569,10 @@ impl AstNode for IsNotJson { &self.syntax } } -impl AstNode for IsNotJsonArray { +impl AstNode for JsonPassingClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_NOT_JSON_ARRAY + kind == SyntaxKind::JSON_PASSING_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -20050,10 +22587,10 @@ impl AstNode for IsNotJsonArray { &self.syntax } } -impl AstNode for IsNotJsonObject { +impl AstNode for JsonPathClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_NOT_JSON_OBJECT + kind == SyntaxKind::JSON_PATH_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -20068,10 +22605,10 @@ impl AstNode for IsNotJsonObject { &self.syntax } } -impl AstNode for IsNotJsonScalar { +impl AstNode for JsonQueryFn { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_NOT_JSON_SCALAR + kind == SyntaxKind::JSON_QUERY_FN } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -20086,10 +22623,10 @@ impl AstNode for IsNotJsonScalar { &self.syntax } } -impl AstNode for IsNotJsonValue { +impl AstNode for JsonQuotesClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_NOT_JSON_VALUE + kind == SyntaxKind::JSON_QUOTES_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -20104,10 +22641,10 @@ impl AstNode for IsNotJsonValue { &self.syntax } } -impl AstNode for IsNotNormalized { +impl AstNode for JsonReturningClause { #[inline] fn can_cast(kind: SyntaxKind) -> bool { - kind == SyntaxKind::IS_NOT_NORMALIZED + kind == SyntaxKind::JSON_RETURNING_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option { @@ -20122,10 +22659,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 { @@ -20140,10 +22677,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 { @@ -20158,10 +22695,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 { @@ -20176,10 +22713,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 { @@ -20194,10 +22731,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 { @@ -20212,10 +22749,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 { @@ -20230,10 +22767,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 { @@ -20248,10 +22785,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 { @@ -20266,10 +22803,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 { @@ -20284,10 +22821,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 { @@ -20302,10 +22839,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 { @@ -20320,10 +22857,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 { @@ -20338,10 +22875,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 { @@ -20356,10 +22893,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 { @@ -20374,10 +22911,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 { @@ -20392,10 +22929,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 { @@ -20410,10 +22947,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 { @@ -20428,10 +22965,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 { @@ -20446,10 +22983,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 { @@ -20464,10 +23001,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 { @@ -20482,10 +23019,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 { @@ -20500,10 +23037,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 { @@ -20518,10 +23055,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 { @@ -20536,10 +23073,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 { @@ -20554,10 +23091,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 { @@ -20572,10 +23109,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 { @@ -20590,10 +23127,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 { @@ -20608,10 +23145,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 { @@ -20626,10 +23163,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 { @@ -20644,10 +23181,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 { @@ -20662,10 +23199,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 { @@ -20680,10 +23217,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 { @@ -20698,10 +23235,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 { @@ -20716,10 +23253,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 { @@ -20734,10 +23271,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 { @@ -20752,10 +23289,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 { @@ -20770,10 +23307,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 { @@ -20788,10 +23325,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 { @@ -20806,10 +23343,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 { @@ -20824,10 +23361,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 { @@ -20842,10 +23379,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 { @@ -20860,10 +23397,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 { @@ -20878,10 +23415,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 { @@ -20896,10 +23433,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 { @@ -20914,10 +23451,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 { @@ -20932,10 +23469,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 { @@ -20950,10 +23487,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 { @@ -20968,10 +23505,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 { @@ -20986,10 +23523,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 { @@ -21004,10 +23541,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 { @@ -21022,10 +23559,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 { @@ -21040,10 +23577,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 { @@ -21058,10 +23595,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 { @@ -21076,10 +23613,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 { @@ -21094,10 +23631,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 { @@ -21112,10 +23649,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 { @@ -21130,10 +23667,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 { @@ -21148,10 +23685,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 { @@ -21166,10 +23703,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 { @@ -21184,10 +23721,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 { @@ -21202,10 +23739,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 { @@ -21220,10 +23757,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 { @@ -21238,10 +23775,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 { @@ -21256,10 +23793,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 { @@ -21274,10 +23811,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 { @@ -21292,10 +23829,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 { @@ -21310,10 +23847,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 { @@ -21328,10 +23865,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 { @@ -21346,10 +23883,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 { @@ -21364,10 +23901,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 { @@ -21382,10 +23919,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 { @@ -21400,10 +23937,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 { @@ -21418,10 +23955,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 { @@ -21436,10 +23973,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 { @@ -21454,10 +23991,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 { @@ -21472,10 +24009,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 { @@ -21490,10 +24027,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 { @@ -21508,10 +24045,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 { @@ -21526,10 +24063,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 { @@ -21544,10 +24081,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 { @@ -21562,10 +24099,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 { @@ -21580,10 +24117,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 { @@ -21598,10 +24135,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 { @@ -21616,10 +24153,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 { @@ -21634,10 +24171,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 { @@ -21652,10 +24189,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 { @@ -21670,10 +24207,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 { @@ -21688,10 +24225,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 { @@ -21706,10 +24243,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 { @@ -21724,10 +24261,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 { @@ -21742,10 +24279,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 { @@ -21760,10 +24297,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 { @@ -21778,10 +24315,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 { @@ -21796,10 +24333,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 { @@ -21814,10 +24351,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 { @@ -21832,10 +24369,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 { @@ -21850,10 +24387,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 { @@ -21868,10 +24405,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 { @@ -21886,10 +24423,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 { @@ -21904,10 +24441,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 { @@ -21922,10 +24459,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 { @@ -21940,10 +24477,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 { @@ -21958,10 +24495,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 { @@ -21976,10 +24513,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 { @@ -21994,10 +24531,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 { @@ -22012,10 +24549,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 { @@ -22030,10 +24567,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 { @@ -22048,10 +24585,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 { @@ -22066,10 +24603,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 { @@ -22084,10 +24621,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 { @@ -22102,10 +24639,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 { @@ -22120,10 +24657,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 { @@ -22138,10 +24675,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 { @@ -22156,10 +24693,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 { @@ -22174,10 +24711,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 { @@ -22192,10 +24729,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 { @@ -22210,10 +24747,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 { @@ -22228,10 +24765,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 { @@ -22246,10 +24783,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 { @@ -22264,10 +24801,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 { @@ -22282,10 +24819,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 { @@ -22300,10 +24837,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 { @@ -22318,10 +24855,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 { @@ -22336,10 +24873,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 { @@ -22354,10 +24891,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 { @@ -22372,10 +24909,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 { @@ -22390,10 +24927,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 { @@ -22408,10 +24945,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 { @@ -22426,10 +24963,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 { @@ -22444,10 +24981,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 { @@ -22462,10 +24999,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 { @@ -22480,10 +25017,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 { @@ -22498,10 +25035,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 { @@ -22516,10 +25053,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 { @@ -22534,10 +25071,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 { @@ -22552,10 +25089,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 { @@ -22570,10 +25107,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 { @@ -22588,10 +25125,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 { @@ -22606,10 +25143,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 { @@ -22624,10 +25161,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 { @@ -22642,10 +25179,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 { @@ -22660,10 +25197,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 { @@ -22678,10 +25215,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 { @@ -22696,10 +25233,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 { @@ -22714,10 +25251,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 { @@ -22732,10 +25269,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 { @@ -22750,10 +25287,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 { @@ -22768,10 +25305,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 { @@ -22786,10 +25323,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 { @@ -22804,10 +25341,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 { @@ -22822,10 +25359,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 { @@ -22840,10 +25377,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 { @@ -22858,10 +25395,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 { @@ -22876,10 +25413,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 { @@ -22894,10 +25431,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 { @@ -22912,10 +25449,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 { @@ -22930,10 +25467,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 { @@ -22948,10 +25485,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 { @@ -22966,10 +25503,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 { @@ -22984,10 +25521,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 { @@ -23002,10 +25539,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 { @@ -23020,10 +25557,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 { @@ -23038,10 +25575,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 { @@ -23056,10 +25593,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 { @@ -23074,10 +25611,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 { @@ -23092,10 +25629,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 { @@ -23110,10 +25647,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 { @@ -23128,10 +25665,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 { @@ -23146,10 +25683,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 { @@ -23164,10 +25701,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 { @@ -23182,10 +25719,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 { @@ -23200,10 +25737,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 { @@ -23218,10 +25755,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 { @@ -23236,10 +25773,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 { @@ -23254,10 +25791,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 { @@ -23272,10 +25809,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 { @@ -23290,10 +25827,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 { @@ -23308,10 +25845,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 { @@ -23326,10 +25863,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 { @@ -23344,10 +25881,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 { @@ -23362,10 +25899,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 { @@ -23380,10 +25917,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 { @@ -23398,10 +25935,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 { @@ -23416,10 +25953,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 { @@ -23434,10 +25971,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 { @@ -23452,10 +25989,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 { @@ -23470,10 +26007,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 { @@ -23488,10 +26025,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 { @@ -23506,10 +26043,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 { @@ -23524,10 +26061,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 { @@ -23542,10 +26079,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 { @@ -23560,10 +26097,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 { @@ -23578,10 +26115,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 { @@ -23596,10 +26133,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 { @@ -23614,10 +26151,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 { @@ -23632,10 +26169,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 { @@ -23650,10 +26187,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 { @@ -23668,10 +26205,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 { @@ -23686,10 +26223,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 { @@ -23704,10 +26241,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 { @@ -23722,10 +26259,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 { @@ -23740,10 +26277,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 { @@ -23758,10 +26295,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 { @@ -23776,10 +26313,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 { @@ -23794,10 +26331,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 { @@ -23812,10 +26349,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 { @@ -23830,10 +26367,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 { @@ -23848,10 +26385,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 { @@ -23866,10 +26403,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 { @@ -23884,10 +26421,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 { @@ -23902,10 +26439,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 { @@ -23920,10 +26457,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 { @@ -23938,10 +26475,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 { @@ -23956,10 +26493,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 { @@ -23974,10 +26511,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 { @@ -23992,10 +26529,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 { @@ -24010,10 +26547,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 { @@ -24028,10 +26565,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 { @@ -24046,10 +26583,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 { @@ -24064,10 +26601,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 { @@ -24082,10 +26619,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 { @@ -24100,10 +26637,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 { @@ -24118,10 +26655,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 { @@ -24136,10 +26673,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 { @@ -24154,10 +26691,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 { @@ -24172,10 +26709,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 { @@ -24190,10 +26727,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 { @@ -24208,10 +26745,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 { @@ -24226,10 +26763,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 { @@ -24244,10 +26781,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 { @@ -24262,10 +26799,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 { @@ -24280,10 +26817,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 { @@ -24298,10 +26835,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 { @@ -24316,10 +26853,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 { @@ -24334,10 +26871,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 { @@ -24352,10 +26889,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 { @@ -24370,10 +26907,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 { @@ -24388,10 +26925,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 { @@ -24406,10 +26943,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 { @@ -24424,10 +26961,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 { @@ -24442,10 +26979,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 { @@ -24460,10 +26997,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 { @@ -24478,10 +27015,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 { @@ -24496,10 +27033,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 { @@ -24514,10 +27051,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 { @@ -24532,10 +27069,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 { @@ -24550,10 +27087,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 { @@ -24568,10 +27105,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 { @@ -24586,10 +27123,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 { @@ -24604,10 +27141,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 { @@ -24622,10 +27159,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 { @@ -24640,10 +27177,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 { @@ -24658,10 +27195,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 { @@ -24676,10 +27213,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 { @@ -24694,10 +27231,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 { @@ -24712,10 +27249,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 { @@ -24730,10 +27267,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 { @@ -24748,10 +27285,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 { @@ -24766,10 +27303,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 { @@ -24784,10 +27321,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 { @@ -24802,10 +27339,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 { @@ -24820,10 +27357,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 { @@ -24838,10 +27375,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 { @@ -24856,10 +27393,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 { @@ -24874,10 +27411,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 { @@ -24892,10 +27429,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 { @@ -24910,10 +27447,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 { @@ -24928,10 +27465,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 { @@ -24946,10 +27483,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 { @@ -24964,10 +27501,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 { @@ -24982,10 +27519,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 { @@ -25000,10 +27537,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 { @@ -25018,10 +27555,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 { @@ -25036,10 +27573,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 { @@ -25054,10 +27591,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 { @@ -25072,10 +27609,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 { @@ -25090,10 +27627,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 { @@ -25108,10 +27645,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 { @@ -25126,10 +27663,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 { @@ -25144,10 +27681,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 { @@ -25162,10 +27699,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 { @@ -25180,10 +27717,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 { @@ -25198,10 +27735,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 { @@ -25216,10 +27753,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 { @@ -25234,10 +27771,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 { @@ -25252,10 +27789,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 { @@ -25270,10 +27807,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 { diff --git a/crates/squawk_syntax/src/postgresql.ungram b/crates/squawk_syntax/src/postgresql.ungram index 71569f25..5d4c1fdb 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,271 @@ ArgList = CallExpr = Expr ArgList WithinClause? FilterClause? OverClause? +| ExtractFn +| JsonExistsFn +| JsonArrayFn +| JsonObjectFn +| JsonObjectAggFn +| JsonArrayAggFn +| JsonQueryFn +| 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? + ')' + +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 +351,7 @@ NamedArg = NameRef FatArrow Expr JsonFormatClause = - 'format' 'json' ('encoding' Name)? + 'format' 'json' JsonEncodingClause? JsonValueExpr = Expr JsonFormatClause? @@ -122,7 +378,7 @@ NotIlike = 'not' 'ilike' CustomOp = - ('+' | '-' | '*' | '/' | '<' | '>' | '=' | '~' | '!' | '@' | '#' | '%' | '^' | '&' | '|' | '`' | '?') + '+' | '-' | '*' | '/' | '<' | '>' | '=' | '~' | '!' | '@' | '#' | '%' | '^' | '&' | '|' | '`' | '?' NotIn = 'not' 'in' @@ -296,6 +552,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 +711,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 +899,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 +921,7 @@ ConstraintIncludeClause = 'include' WithParams = - 'with' '(' ')' + 'with' AttributeList ConstraintIndexTablespace = 'using' 'index' 'tablespace' NameRef @@ -836,7 +1091,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 +1406,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 +1464,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 +1528,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 +1538,11 @@ JsonOnErrorClause = JsonOnEmptyClause = JsonBehavior 'on' 'empty' +JsonBehaviorClause = + JsonBehavior + JsonPassingArg = - Expr JsonFormatClause? 'as' Name + Expr JsonPassingClause = 'passing' (JsonPassingArg (',' JsonPassingArg)*) @@ -1371,11 +1665,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 +1709,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 +2126,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 +2148,8 @@ RoleOption = 'inherit' CreateLanguage = - 'create' 'language' Name + 'create' OrReplace 'trusted'? 'procedural'? 'language' Name + ('handler' Path ('inline' Path)? ('validator' Path)?)? CreateOperator = 'create' 'operator' @@ -1859,15 +2171,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 +2203,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 +2248,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 +2274,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 +2333,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 +2518,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') From b922d356e7b842ae0f21ed7402a470a0e812df5f Mon Sep 17 00:00:00 2001 From: Steve Dignam Date: Thu, 4 Dec 2025 21:55:31 -0500 Subject: [PATCH 2/2] fix --- .../src/generated/syntax_kind.rs | 1 + crates/squawk_parser/src/grammar.rs | 142 +++++++----- .../snapshots/tests__regression_sqljson.snap | 208 +----------------- .../snapshots/tests__select_funcs_ok.snap | 3 +- crates/squawk_parser/tests/tests.rs | 5 + .../squawk_syntax/src/ast/generated/nodes.rs | 45 ++++ crates/squawk_syntax/src/postgresql.ungram | 8 +- crates/xtask/src/codegen.rs | 3 + 8 files changed, 147 insertions(+), 268 deletions(-) diff --git a/crates/squawk_parser/src/generated/syntax_kind.rs b/crates/squawk_parser/src/generated/syntax_kind.rs index eca0a22b..bf8c57e2 100644 --- a/crates/squawk_parser/src/generated/syntax_kind.rs +++ b/crates/squawk_parser/src/generated/syntax_kind.rs @@ -875,6 +875,7 @@ pub enum SyntaxKind { JSON_QUERY_FN, JSON_QUOTES_CLAUSE, JSON_RETURNING_CLAUSE, + JSON_SCALAR_FN, JSON_SELECT_FORMAT, JSON_SERIALIZE_FN, JSON_TABLE, diff --git a/crates/squawk_parser/src/grammar.rs b/crates/squawk_parser/src/grammar.rs index 63bea710..1e0b739f 100644 --- a/crates/squawk_parser/src/grammar.rs +++ b/crates/squawk_parser/src/grammar.rs @@ -256,7 +256,9 @@ fn extract_fn(p: &mut Parser<'_>) -> CompletedMarker { p.error("expected an expression"); } p.expect(R_PAREN); - m.complete(p, EXTRACT_FN).precede(p).complete(p, CALL_EXPR) + let m = m.complete(p, EXTRACT_FN).precede(p); + opt_agg_clauses(p); + m.complete(p, CALL_EXPR) } // | OVERLAY '(' overlay_list ')' @@ -289,7 +291,9 @@ fn overlay_fn(p: &mut Parser<'_>) -> CompletedMarker { } } p.expect(R_PAREN); - m.complete(p, OVERLAY_FN).precede(p).complete(p, CALL_EXPR) + let m = m.complete(p, OVERLAY_FN).precede(p); + opt_agg_clauses(p); + m.complete(p, CALL_EXPR) } // POSITION '(' position_list ')' @@ -321,7 +325,9 @@ fn position_fn(p: &mut Parser<'_>) -> CompletedMarker { p.error("expected an expression"); } p.expect(R_PAREN); - m.complete(p, POSITION_FN).precede(p).complete(p, CALL_EXPR) + 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 { @@ -350,7 +356,9 @@ fn trim_fn(p: &mut Parser<'_>) -> CompletedMarker { } }; p.expect(R_PAREN); - m.complete(p, TRIM_FN).precede(p).complete(p, CALL_EXPR) + let m = m.complete(p, TRIM_FN).precede(p); + opt_agg_clauses(p); + m.complete(p, CALL_EXPR) } // SUBSTRING '(' substr_list ')' @@ -408,9 +416,9 @@ fn substring_fn(p: &mut Parser<'_>) -> CompletedMarker { _ => {} } p.expect(R_PAREN); - m.complete(p, SUBSTRING_FN) - .precede(p) - .complete(p, CALL_EXPR) + 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<'_>) { @@ -561,9 +569,9 @@ fn json_object_fn(p: &mut Parser<'_>) -> CompletedMarker { p.expect(L_PAREN); json_object_fn_arg_list(p); p.expect(R_PAREN); - m.complete(p, JSON_OBJECT_FN) - .precede(p) - .complete(p, CALL_EXPR) + 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 { @@ -576,9 +584,9 @@ fn json_objectagg_fn(p: &mut Parser<'_>) -> CompletedMarker { opt_json_keys_unique_clause(p); opt_json_returning_clause(p); p.expect(R_PAREN); - m.complete(p, JSON_OBJECT_AGG_FN) - .precede(p) - .complete(p, CALL_EXPR) + let m = m.complete(p, JSON_OBJECT_AGG_FN).precede(p); + opt_agg_clauses(p); + m.complete(p, CALL_EXPR) } /// @@ -746,9 +754,9 @@ fn json_array_fn(p: &mut Parser<'_>) -> CompletedMarker { p.expect(L_PAREN); opt_json_array_fn_arg_list(p); p.expect(R_PAREN); - m.complete(p, JSON_ARRAY_FN) - .precede(p) - .complete(p, CALL_EXPR) + let m = m.complete(p, JSON_ARRAY_FN).precede(p); + opt_agg_clauses(p); + m.complete(p, CALL_EXPR) } /// @@ -775,7 +783,9 @@ fn some_any_all_fn(p: &mut Parser<'_>) -> CompletedMarker { } } p.expect(R_PAREN); - m.complete(p, kind).precede(p).complete(p, CALL_EXPR) + let m = m.complete(p, kind).precede(p); + opt_agg_clauses(p); + m.complete(p, CALL_EXPR) } // literal, path, tuple, array @@ -809,6 +819,7 @@ fn atom_expr(p: &mut Parser<'_>) -> Option { (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), @@ -858,9 +869,9 @@ fn json_arrayagg_fn(p: &mut Parser<'_>) -> CompletedMarker { opt_json_null_clause(p); opt_json_returning_clause(p); p.expect(R_PAREN); - m.complete(p, JSON_ARRAY_AGG_FN) - .precede(p) - .complete(p, CALL_EXPR) + 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 { @@ -874,7 +885,9 @@ fn exists_fn(p: &mut Parser<'_>) -> CompletedMarker { p.error("expected select"); } p.expect(R_PAREN); - m.complete(p, EXISTS_FN).precede(p).complete(p, CALL_EXPR) + let m = m.complete(p, EXISTS_FN).precede(p); + opt_agg_clauses(p); + m.complete(p, CALL_EXPR) } // XMLPI '(' NAME_P ColLabel ',' a_expr ')' @@ -890,7 +903,9 @@ fn xmlpi_fn(p: &mut Parser<'_>) -> CompletedMarker { p.error("expected expr"); } p.expect(R_PAREN); - m.complete(p, XML_PI_FN).precede(p).complete(p, CALL_EXPR) + 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 ')' @@ -918,9 +933,9 @@ fn xmlparse_fn(p: &mut Parser<'_>) -> CompletedMarker { p.expect(WHITESPACE_KW); } p.expect(R_PAREN); - m.complete(p, XML_PARSE_FN) - .precede(p) - .complete(p, CALL_EXPR) + 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 { @@ -953,9 +968,9 @@ fn xmlexists_fn(p: &mut Parser<'_>) -> CompletedMarker { p.expect(L_PAREN); xml_row_passing_clause(p); p.expect(R_PAREN); - m.complete(p, XML_EXISTS_FN) - .precede(p) - .complete(p, CALL_EXPR) + 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 ')' @@ -991,9 +1006,9 @@ fn xmlelement_fn(p: &mut Parser<'_>) -> CompletedMarker { } } p.expect(R_PAREN); - m.complete(p, XML_ELEMENT_FN) - .precede(p) - .complete(p, CALL_EXPR) + 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<'_>) { @@ -1023,9 +1038,9 @@ fn xmlforest_fn(p: &mut Parser<'_>) -> CompletedMarker { p.expect(L_PAREN); xml_attribute_list(p); p.expect(R_PAREN); - m.complete(p, XML_FOREST_FN) - .precede(p) - .complete(p, CALL_EXPR) + 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 ')' @@ -1054,9 +1069,9 @@ fn xmlserialize_fn(p: &mut Parser<'_>) -> CompletedMarker { p.eat(INDENT_KW); } p.expect(R_PAREN); - m.complete(p, XML_SERIALIZE_FN) - .precede(p) - .complete(p, CALL_EXPR) + 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 ')' @@ -1092,7 +1107,9 @@ fn xmlroot_fn(p: &mut Parser<'_>) -> CompletedMarker { } } p.expect(R_PAREN); - m.complete(p, XML_ROOT_FN).precede(p).complete(p, CALL_EXPR) + 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 ')' @@ -1102,13 +1119,26 @@ fn json_fn(p: &mut Parser<'_>) -> CompletedMarker { p.expect(JSON_KW); p.expect(L_PAREN); // json_value_expr - if expr(p).is_none() { - p.error("expected expression"); - } + opt_expr(p); opt_json_format_clause(p); opt_json_keys_unique_clause(p); p.expect(R_PAREN); - m.complete(p, JSON_FN).precede(p).complete(p, CALL_EXPR) + 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 '(' @@ -1134,9 +1164,9 @@ fn json_value_fn(p: &mut Parser<'_>) -> CompletedMarker { opt_json_returning_clause(p); opt_json_behavior_clause(p); p.expect(R_PAREN); - m.complete(p, JSON_VALUE_FN) - .precede(p) - .complete(p, CALL_EXPR) + 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 ')' @@ -1145,15 +1175,13 @@ fn json_serialize_fn(p: &mut Parser<'_>) -> CompletedMarker { let m = p.start(); p.expect(JSON_SERIALIZE_KW); p.expect(L_PAREN); - if expr(p).is_none() { - p.error("expected expression"); - } + opt_expr(p); opt_json_format_clause(p); opt_json_returning_clause(p); p.expect(R_PAREN); - m.complete(p, JSON_SERIALIZE_FN) - .precede(p) - .complete(p, CALL_EXPR) + let m = m.complete(p, JSON_SERIALIZE_FN).precede(p); + opt_agg_clauses(p); + m.complete(p, CALL_EXPR) } // JSON_QUERY ( @@ -1186,9 +1214,9 @@ fn json_query_fn(p: &mut Parser<'_>) -> CompletedMarker { opt_json_quotes_clause(p); opt_json_behavior_clause(p); p.expect(R_PAREN); - m.complete(p, JSON_QUERY_FN) - .precede(p) - .complete(p, CALL_EXPR) + 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 { @@ -1279,9 +1307,9 @@ fn json_exists_fn(p: &mut Parser<'_>) -> CompletedMarker { opt_json_passing_clause(p); opt_json_on_error_clause(p); p.expect(R_PAREN); - m.complete(p, JSON_EXISTS_FN) - .precede(p) - .complete(p, CALL_EXPR) + 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<'_>) { diff --git a/crates/squawk_parser/tests/snapshots/tests__regression_sqljson.snap b/crates/squawk_parser/tests/snapshots/tests__regression_sqljson.snap index d68e7493..7c4c9dd3 100644 --- a/crates/squawk_parser/tests/snapshots/tests__regression_sqljson.snap +++ b/crates/squawk_parser/tests/snapshots/tests__regression_sqljson.snap @@ -2,210 +2,4 @@ source: crates/squawk_parser/tests/tests.rs input_file: crates/squawk_parser/tests/data/regression_suite/sqljson.sql --- -ERROR@22: expected an expression, found R_PAREN -ERROR@22: expected expression -ERROR@1596: expected an expression, found R_PAREN -ERROR@1596: expected expression -ERROR@9659: missing comma -ERROR@9668: expected an expression, found WHERE_KW -ERROR@9673: expected R_PAREN -ERROR@9677: missing comma -ERROR@9681: expected SEMICOLON -ERROR@9681: expected command, found R_PAREN -ERROR@9683: expected command, found AS_KW -ERROR@9686: expected command, found IDENT -ERROR@9702: expected command, found COMMA -ERROR@9705: expected command, found JSON_ARRAYAGG_KW -ERROR@9719: expected R_PAREN -ERROR@9719: expected SEMICOLON -ERROR@9719: expected command, found IDENT -ERROR@9723: expected command, found ORDER_KW -ERROR@9729: expected command, found BY_KW -ERROR@9732: expected command, found IDENT -ERROR@9736: expected command, found RETURNING_KW -ERROR@9746: expected command, found IDENT -ERROR@9751: expected command, found R_PAREN -ERROR@9753: expected command, found FILTER_KW -ERROR@9761: expected R_PAREN -ERROR@9761: expected SEMICOLON -ERROR@9761: expected command, found WHERE_KW -ERROR@9767: expected command, found IDENT -ERROR@9771: expected command, found R_ANGLE -ERROR@9773: expected command, found INT_NUMBER -ERROR@9774: expected command, found R_PAREN -ERROR@9776: expected command, found AS_KW -ERROR@9779: expected command, found IDENT -ERROR@9812: expected command, found FROM_KW -ERROR@9882: expected SEMICOLON -ERROR@9883: expected command, found IDENT -ERROR@9887: expected R_PAREN -ERROR@9887: expected SEMICOLON -ERROR@9887: expected command, found IDENT -ERROR@9890: expected command, found R_PAREN -ERROR@9925: missing comma -ERROR@9934: expected an expression, found WHERE_KW -ERROR@9939: expected R_PAREN -ERROR@9943: missing comma -ERROR@9947: expected SEMICOLON -ERROR@9947: expected command, found R_PAREN -ERROR@9949: expected command, found OVER_KW -ERROR@9955: expected R_PAREN -ERROR@9955: expected SEMICOLON -ERROR@9955: expected command, found PARTITION_KW -ERROR@9965: expected command, found BY_KW -ERROR@9968: expected command, found IDENT -ERROR@9971: expected command, found DOT -ERROR@9972: expected command, found IDENT -ERROR@9976: expected command, found PERCENT -ERROR@9978: expected command, found INT_NUMBER -ERROR@9979: expected command, found R_PAREN -ERROR@9981: expected command, found FROM_KW -ERROR@10061: expected SEMICOLON -ERROR@10062: expected command, found IDENT -ERROR@10066: expected R_PAREN -ERROR@10066: expected SEMICOLON -ERROR@10066: expected command, found IDENT -ERROR@10069: expected command, found R_PAREN -ERROR@11936: missing comma -ERROR@11943: expected an expression, found ORDER_KW -ERROR@11948: expected R_PAREN -ERROR@11951: missing comma -ERROR@11953: expected SEMICOLON -ERROR@11953: expected command, found R_PAREN -ERROR@11955: expected command, found FROM_KW -ERROR@11981: expected SEMICOLON -ERROR@11982: expected command, found IDENT -ERROR@11984: expected R_PAREN -ERROR@11984: expected SEMICOLON -ERROR@11984: expected command, found IDENT -ERROR@11985: expected command, found COMMA -ERROR@11986: expected command, found IDENT -ERROR@11987: expected command, found R_PAREN -ERROR@12053: missing comma -ERROR@12060: expected an expression, found ORDER_KW -ERROR@12065: expected R_PAREN -ERROR@12068: missing comma -ERROR@12070: expected SEMICOLON -ERROR@12070: expected command, found R_PAREN -ERROR@12072: expected command, found FROM_KW -ERROR@12105: expected SEMICOLON -ERROR@12106: expected command, found IDENT -ERROR@12108: expected R_PAREN -ERROR@12108: expected SEMICOLON -ERROR@12108: expected command, found IDENT -ERROR@12109: expected command, found COMMA -ERROR@12110: expected command, found IDENT -ERROR@12111: expected command, found R_PAREN -ERROR@12192: missing comma -ERROR@12202: expected an expression, found ORDER_KW -ERROR@12207: expected R_PAREN -ERROR@12210: missing comma -ERROR@12212: expected SEMICOLON -ERROR@12212: expected command, found R_PAREN -ERROR@12214: expected command, found FROM_KW -ERROR@12250: expected SEMICOLON -ERROR@12251: expected command, found IDENT -ERROR@12253: expected R_PAREN -ERROR@12253: expected SEMICOLON -ERROR@12253: expected command, found IDENT -ERROR@12254: expected command, found COMMA -ERROR@12255: expected command, found IDENT -ERROR@12256: expected command, found R_PAREN -ERROR@12320: missing comma -ERROR@12327: expected an expression, found ORDER_KW -ERROR@12332: expected R_PAREN -ERROR@12335: missing comma -ERROR@12337: expected SEMICOLON -ERROR@12337: expected command, found R_PAREN -ERROR@12339: expected command, found FROM_KW -ERROR@12375: expected SEMICOLON -ERROR@12376: expected command, found IDENT -ERROR@12378: expected R_PAREN -ERROR@12378: expected SEMICOLON -ERROR@12378: expected command, found IDENT -ERROR@12379: expected command, found COMMA -ERROR@12380: expected command, found IDENT -ERROR@12381: expected command, found R_PAREN -ERROR@12445: missing comma -ERROR@12452: expected an expression, found ORDER_KW -ERROR@12457: expected R_PAREN -ERROR@12460: missing comma -ERROR@12468: missing comma -ERROR@12486: missing comma -ERROR@12520: expected SEMICOLON -ERROR@12520: expected command, found R_PAREN -ERROR@12522: expected command, found FROM_KW -ERROR@12558: expected SEMICOLON -ERROR@12559: expected command, found IDENT -ERROR@12561: expected R_PAREN -ERROR@12561: expected SEMICOLON -ERROR@12561: expected command, found IDENT -ERROR@12562: expected command, found COMMA -ERROR@12563: expected command, found IDENT -ERROR@12564: expected command, found R_PAREN -ERROR@12942: missing comma -ERROR@12951: expected an expression, found WHERE_KW -ERROR@12956: expected R_PAREN -ERROR@12958: missing comma -ERROR@12962: expected SEMICOLON -ERROR@12962: expected command, found R_PAREN -ERROR@12964: expected command, found FROM_KW -ERROR@12969: expected command, found IDENT -ERROR@12985: expected R_PAREN -ERROR@12985: expected SEMICOLON -ERROR@12985: expected command, found INT_NUMBER -ERROR@12986: expected command, found COMMA -ERROR@12987: expected command, found INT_NUMBER -ERROR@12988: expected command, found R_PAREN -ERROR@12990: expected command, found IDENT -ERROR@13107: missing comma -ERROR@13123: expected COMMA -ERROR@13126: expected COMMA -ERROR@13283: missing comma -ERROR@13292: expected an expression, found WHERE_KW -ERROR@13297: expected R_PAREN -ERROR@13299: missing comma -ERROR@13303: expected SEMICOLON -ERROR@13303: expected command, found R_PAREN -ERROR@13305: expected command, found FROM_KW -ERROR@13310: expected command, found IDENT -ERROR@13326: expected R_PAREN -ERROR@13326: expected SEMICOLON -ERROR@13326: expected command, found INT_NUMBER -ERROR@13327: expected command, found COMMA -ERROR@13328: expected command, found INT_NUMBER -ERROR@13329: expected command, found R_PAREN -ERROR@13331: expected command, found IDENT -ERROR@13510: missing comma -ERROR@13519: expected an expression, found WHERE_KW -ERROR@13524: expected R_PAREN -ERROR@13526: missing comma -ERROR@13530: expected SEMICOLON -ERROR@13530: expected command, found R_PAREN -ERROR@13532: expected command, found FROM_KW -ERROR@13537: expected command, found IDENT -ERROR@13553: expected R_PAREN -ERROR@13553: expected SEMICOLON -ERROR@13553: expected command, found INT_NUMBER -ERROR@13554: expected command, found COMMA -ERROR@13555: expected command, found INT_NUMBER -ERROR@13556: expected command, found R_PAREN -ERROR@13558: expected command, found IDENT -ERROR@13672: missing comma -ERROR@13688: expected COMMA -ERROR@13691: expected COMMA -ERROR@13844: missing comma -ERROR@13853: expected an expression, found WHERE_KW -ERROR@13858: expected R_PAREN -ERROR@13860: missing comma -ERROR@13864: expected SEMICOLON -ERROR@13864: expected command, found R_PAREN -ERROR@13866: expected command, found FROM_KW -ERROR@13871: expected command, found IDENT -ERROR@13887: expected R_PAREN -ERROR@13887: expected SEMICOLON -ERROR@13887: expected command, found INT_NUMBER -ERROR@13888: expected command, found COMMA -ERROR@13889: expected command, found INT_NUMBER -ERROR@13890: expected command, found R_PAREN -ERROR@13892: expected command, found IDENT + 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 ba612ffc..3c6d7a09 100644 --- a/crates/squawk_parser/tests/snapshots/tests__select_funcs_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__select_funcs_ok.snap @@ -2384,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" 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) { diff --git a/crates/squawk_syntax/src/ast/generated/nodes.rs b/crates/squawk_syntax/src/ast/generated/nodes.rs index 3593499d..e0f0aec0 100644 --- a/crates/squawk_syntax/src/ast/generated/nodes.rs +++ b/crates/squawk_syntax/src/ast/generated/nodes.rs @@ -2185,6 +2185,10 @@ impl CallExpr { support::child(&self.syntax) } #[inline] + pub fn json_scalar_fn(&self) -> Option { + support::child(&self.syntax) + } + #[inline] pub fn json_serialize_fn(&self) -> Option { support::child(&self.syntax) } @@ -9426,6 +9430,29 @@ impl JsonReturningClause { } } +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct JsonScalarFn { + pub(crate) syntax: SyntaxNode, +} +impl JsonScalarFn { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn json_scalar_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::JSON_SCALAR_KW) + } +} + #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct JsonSelectFormat { pub(crate) syntax: SyntaxNode, @@ -22659,6 +22686,24 @@ impl AstNode for JsonReturningClause { &self.syntax } } +impl AstNode for JsonScalarFn { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_SCALAR_FN + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } +} impl AstNode for JsonSelectFormat { #[inline] fn can_cast(kind: SyntaxKind) -> bool { diff --git a/crates/squawk_syntax/src/postgresql.ungram b/crates/squawk_syntax/src/postgresql.ungram index 5d4c1fdb..28aace36 100644 --- a/crates/squawk_syntax/src/postgresql.ungram +++ b/crates/squawk_syntax/src/postgresql.ungram @@ -68,9 +68,10 @@ CallExpr = | JsonExistsFn | JsonArrayFn | JsonObjectFn -| JsonObjectAggFn -| JsonArrayAggFn +| JsonObjectAggFn WithinClause? FilterClause? OverClause? +| JsonArrayAggFn WithinClause? FilterClause? OverClause? | JsonQueryFn +| JsonScalarFn | JsonSerializeFn | JsonValueFn | JsonFn @@ -99,6 +100,9 @@ JsonArrayFn = JsonReturningClause? ')' +JsonScalarFn = + 'json_scalar' '(' Expr ')' + JsonFn = 'json' '(' JsonExprFormat JsonKeysUniqueClause? ')' 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, 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;