From 89ae6c5d8614631d9d699ffea6a723ea32e26271 Mon Sep 17 00:00:00 2001 From: Steve Dignam Date: Thu, 22 May 2025 19:25:45 -0400 Subject: [PATCH 1/7] wip --- .vscode/settings.json | 3 + Cargo.lock | 29 +- Cargo.toml | 4 + crates/squawk_lexer/src/lib.rs | 2 +- crates/squawk_lexer/src/token.rs | 2 +- .../src/rules/adding_field_with_default.rs | 6 +- .../rules/adding_foreign_key_constraint.rs | 6 +- .../src/rules/adding_not_null_field.rs | 6 +- .../rules/adding_primary_key_constraint.rs | 6 +- .../src/rules/adding_required_field.rs | 6 +- .../ban_alter_domain_with_add_constraint.rs | 6 +- ...oncurrent_index_creation_in_transaction.rs | 9 +- .../ban_create_domain_with_constraint.rs | 6 +- .../src/rules/ban_drop_column.rs | 6 +- .../src/rules/ban_drop_database.rs | 6 +- .../src/rules/ban_drop_not_null.rs | 6 +- .../squawk_linter/src/rules/ban_drop_table.rs | 6 +- .../src/rules/ban_truncate_cascade.rs | 9 +- .../src/rules/changing_column_type.rs | 6 +- .../src/rules/constraint_missing_not_valid.rs | 14 +- .../src/rules/disallow_unique_constraint.rs | 6 +- .../src/rules/prefer_robust_stmts.rs | 8 +- .../src/rules/renaming_column.rs | 6 +- .../squawk_linter/src/rules/renaming_table.rs | 6 +- .../require_concurrent_index_creation.rs | 6 +- .../require_concurrent_index_deletion.rs | 6 +- .../src/rules/transaction_nesting.rs | 6 +- crates/squawk_linter/src/visitors.rs | 8 +- crates/squawk_parser/src/generated/mod.rs | 2 + .../src/generated/syntax_kind.rs | 1959 ++ .../squawk_parser/src/generated/token_sets.rs | 2171 ++ crates/squawk_parser/src/grammar.rs | 106 +- crates/squawk_parser/src/lexed_str.rs | 2 +- crates/squawk_parser/src/lib.rs | 20 +- ..._parser__test__alter_foreign_table_ok.snap | 6 +- .../squawk_parser__test__alter_table_ok.snap | 3 +- ...uawk_parser__test__create_function_ok.snap | 4 +- .../squawk_parser__test__explain_ok.snap | 4 +- .../squawk_parser__test__misc_ok.snap | 46 +- .../squawk_parser__test__select_casts_ok.snap | 194 +- ...test__select_compound_union_select_ok.snap | 4 +- .../squawk_parser__test__select_funcs_ok.snap | 4 +- ...wk_parser__test__select_funcs_pg17_ok.snap | 2 +- ...awk_parser__test__select_operators_ok.snap | 78 +- .../squawk_parser__test__values_ok.snap | 2 +- crates/squawk_parser/src/syntax_kind.rs | 4660 +---- .../test_data/ok/set_transaction.sql | 5 +- crates/squawk_syntax/src/ast.rs | 8 +- crates/squawk_syntax/src/ast/generated/mod.rs | 2 + .../squawk_syntax/src/ast/generated/nodes.rs | 16890 ++++++++++++++++ .../squawk_syntax/src/ast/generated/tokens.rs | 52 + crates/squawk_syntax/src/ast/node_ext.rs | 27 +- crates/squawk_syntax/src/ast/nodes.rs | 4649 +---- crates/squawk_syntax/src/ast/traits.rs | 8 +- crates/squawk_syntax/src/lib.rs | 10 +- crates/squawk_syntax/src/postgresql.ungram | 1477 ++ crates/xtask/Cargo.toml | 4 + crates/xtask/src/codegen.rs | 1626 ++ crates/xtask/src/main.rs | 6 + crates/xtask/src/new_rule.rs | 30 +- crates/xtask/src/path.rs | 6 + postgres/kwlist.h | 526 + 62 files changed, 25111 insertions(+), 9678 deletions(-) create mode 100644 crates/squawk_parser/src/generated/mod.rs create mode 100644 crates/squawk_parser/src/generated/syntax_kind.rs create mode 100644 crates/squawk_parser/src/generated/token_sets.rs create mode 100644 crates/squawk_syntax/src/ast/generated/mod.rs create mode 100644 crates/squawk_syntax/src/ast/generated/nodes.rs create mode 100644 crates/squawk_syntax/src/ast/generated/tokens.rs create mode 100644 crates/squawk_syntax/src/postgresql.ungram create mode 100644 crates/xtask/src/codegen.rs create mode 100644 crates/xtask/src/path.rs create mode 100644 postgres/kwlist.h diff --git a/.vscode/settings.json b/.vscode/settings.json index 7fbf88e3..c29eb164 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -8,5 +8,8 @@ }, "[sql]": { "editor.tabSize": 2 + }, + "[ungrammar]": { + "editor.tabSize": 2 } } diff --git a/Cargo.lock b/Cargo.lock index aabf18f0..be07911c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1941,9 +1941,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.36" +version = "1.0.40" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" +checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" dependencies = [ "proc-macro2", ] @@ -3155,6 +3155,12 @@ dependencies = [ "cfg-if 0.1.10", ] +[[package]] +name = "ungrammar" +version = "1.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3e5df347f0bf3ec1d670aad6ca5c6a1859cd9ea61d2113125794654ccced68f" + [[package]] name = "unicase" version = "2.6.0" @@ -3745,6 +3751,21 @@ dependencies = [ "winapi-build", ] +[[package]] +name = "xshell" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e7290c623014758632efe00737145b6867b66292c42167f2ec381eb566a373d" +dependencies = [ + "xshell-macros", +] + +[[package]] +name = "xshell-macros" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547" + [[package]] name = "xtask" version = "0.1.0" @@ -3754,8 +3775,12 @@ dependencies = [ "clap 4.5.37", "convert_case", "enum-iterator", + "proc-macro2", + "quote", "reqwest 0.12.15", "serde", + "ungrammar", + "xshell", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index c757f6b9..0292cf71 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -45,6 +45,10 @@ annotate-snippets = "0.11.5" anyhow = "1.0.94" convert_case = "0.7.1" clap = { version = "4.5.8", features = ["derive"] } +ungrammar = "1.1.4" +quote = "1.0.40" +xshell = "0.2.7" +proc-macro2 = "1.0.95" # local squawk_github = { version = "0.0.0", path = "./crates/squawk_github" } diff --git a/crates/squawk_lexer/src/lib.rs b/crates/squawk_lexer/src/lib.rs index dff91c6c..5850bae2 100644 --- a/crates/squawk_lexer/src/lib.rs +++ b/crates/squawk_lexer/src/lib.rs @@ -114,7 +114,7 @@ impl Cursor<'_> { while self.first().is_ascii_digit() { self.bump(); } - TokenKind::Param + TokenKind::PositionalParam } } '`' => TokenKind::Backtick, diff --git a/crates/squawk_lexer/src/token.rs b/crates/squawk_lexer/src/token.rs index 5827c672..a768fd66 100644 --- a/crates/squawk_lexer/src/token.rs +++ b/crates/squawk_lexer/src/token.rs @@ -80,7 +80,7 @@ pub enum TokenKind { /// Positional Parameter, e.g., `$1` /// /// see: - Param, + PositionalParam, /// Quoted Identifier, e.g., `"update"` in `update "my_table" set "a" = 5;` /// /// These are case-sensitive, unlike [`TokenKind::Ident`] diff --git a/crates/squawk_linter/src/rules/adding_field_with_default.rs b/crates/squawk_linter/src/rules/adding_field_with_default.rs index fc03201c..2067c7a2 100644 --- a/crates/squawk_linter/src/rules/adding_field_with_default.rs +++ b/crates/squawk_linter/src/rules/adding_field_with_default.rs @@ -3,7 +3,7 @@ use std::collections::HashSet; use squawk_syntax::ast; use squawk_syntax::ast::{AstNode, HasArgList}; -use squawk_syntax::{ast::HasModuleItem, Parse, SourceFile}; +use squawk_syntax::{Parse, SourceFile}; use crate::{Linter, Rule, Violation}; @@ -57,8 +57,8 @@ pub(crate) fn adding_field_with_default(ctx: &mut Linter, parse: &Parse { diff --git a/crates/squawk_linter/src/rules/adding_not_null_field.rs b/crates/squawk_linter/src/rules/adding_not_null_field.rs index 08d05016..fb5ddf5c 100644 --- a/crates/squawk_linter/src/rules/adding_not_null_field.rs +++ b/crates/squawk_linter/src/rules/adding_not_null_field.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -10,8 +10,8 @@ pub(crate) fn adding_not_null_field(ctx: &mut Linter, parse: &Parse) return; } let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::AlterTable(alter_table) = item { + for stmt in file.stmts() { + if let ast::Stmt::AlterTable(alter_table) = stmt { for action in alter_table.actions() { if let ast::AlterTableAction::AlterColumn(alter_column) = action { let Some(option) = alter_column.option() else { diff --git a/crates/squawk_linter/src/rules/adding_primary_key_constraint.rs b/crates/squawk_linter/src/rules/adding_primary_key_constraint.rs index bcc3ce31..fe9a5b64 100644 --- a/crates/squawk_linter/src/rules/adding_primary_key_constraint.rs +++ b/crates/squawk_linter/src/rules/adding_primary_key_constraint.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -9,8 +9,8 @@ pub(crate) fn adding_primary_key_constraint(ctx: &mut Linter, parse: &Parse { diff --git a/crates/squawk_linter/src/rules/adding_required_field.rs b/crates/squawk_linter/src/rules/adding_required_field.rs index 1d23e0e3..2ec683a4 100644 --- a/crates/squawk_linter/src/rules/adding_required_field.rs +++ b/crates/squawk_linter/src/rules/adding_required_field.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -7,8 +7,8 @@ use crate::{Linter, Rule, Violation}; pub(crate) fn adding_required_field(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::AlterTable(alter_table) = item { + for stmt in file.stmts() { + if let ast::Stmt::AlterTable(alter_table) = stmt { for action in alter_table.actions() { if let ast::AlterTableAction::AddColumn(add_column) = action { if has_generated_constrait(add_column.constraints()) { diff --git a/crates/squawk_linter/src/rules/ban_alter_domain_with_add_constraint.rs b/crates/squawk_linter/src/rules/ban_alter_domain_with_add_constraint.rs index 88136da2..118a0558 100644 --- a/crates/squawk_linter/src/rules/ban_alter_domain_with_add_constraint.rs +++ b/crates/squawk_linter/src/rules/ban_alter_domain_with_add_constraint.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -7,8 +7,8 @@ use crate::{Linter, Rule, Violation}; pub(crate) fn ban_alter_domain_with_add_constraint(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::AlterDomain(alter_domain) = item { + for stmt in file.stmts() { + if let ast::Stmt::AlterDomain(alter_domain) = stmt { let actions = alter_domain.actions(); for action in actions { if let ast::AlterDomainAction::AddConstraint(add_constraint) = action { diff --git a/crates/squawk_linter/src/rules/ban_concurrent_index_creation_in_transaction.rs b/crates/squawk_linter/src/rules/ban_concurrent_index_creation_in_transaction.rs index 29079695..f3dde939 100644 --- a/crates/squawk_linter/src/rules/ban_concurrent_index_creation_in_transaction.rs +++ b/crates/squawk_linter/src/rules/ban_concurrent_index_creation_in_transaction.rs @@ -1,7 +1,4 @@ -use squawk_syntax::{ - ast::{self, HasModuleItem}, - Parse, SourceFile, -}; +use squawk_syntax::{ast, Parse, SourceFile}; use crate::{Linter, Rule, Violation}; @@ -13,9 +10,9 @@ pub(crate) fn ban_concurrent_index_creation_in_transaction( let file = parse.tree(); let mut errors = vec![]; let mut stmt_count = 0; - for item in file.items() { + for stmt in file.stmts() { stmt_count += 1; - match item { + match stmt { ast::Stmt::Begin(_) => { in_transaction = true; } diff --git a/crates/squawk_linter/src/rules/ban_create_domain_with_constraint.rs b/crates/squawk_linter/src/rules/ban_create_domain_with_constraint.rs index dc385146..6ab8bf90 100644 --- a/crates/squawk_linter/src/rules/ban_create_domain_with_constraint.rs +++ b/crates/squawk_linter/src/rules/ban_create_domain_with_constraint.rs @@ -1,6 +1,6 @@ use rowan::TextRange; use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -8,8 +8,8 @@ use crate::{Linter, Rule, Violation}; pub(crate) fn ban_create_domain_with_constraint(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::CreateDomain(domain) = item { + for stmt in file.stmts() { + if let ast::Stmt::CreateDomain(domain) = stmt { let range = domain .constraints() diff --git a/crates/squawk_linter/src/rules/ban_drop_column.rs b/crates/squawk_linter/src/rules/ban_drop_column.rs index b5229569..a622efb4 100644 --- a/crates/squawk_linter/src/rules/ban_drop_column.rs +++ b/crates/squawk_linter/src/rules/ban_drop_column.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -7,8 +7,8 @@ use crate::{Linter, Rule, Violation}; pub(crate) fn ban_drop_column(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::AlterTable(alter_table) = item { + for stmt in file.stmts() { + if let ast::Stmt::AlterTable(alter_table) = stmt { for action in alter_table.actions() { if let ast::AlterTableAction::DropColumn(drop_column) = action { ctx.report(Violation::new( diff --git a/crates/squawk_linter/src/rules/ban_drop_database.rs b/crates/squawk_linter/src/rules/ban_drop_database.rs index 4ef115a3..75db6aea 100644 --- a/crates/squawk_linter/src/rules/ban_drop_database.rs +++ b/crates/squawk_linter/src/rules/ban_drop_database.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -8,8 +8,8 @@ use crate::{Linter, Rule, Violation}; /// Brad's Rule aka ban dropping database statements. pub(crate) fn ban_drop_database(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::DropDatabase(drop_database) = item { + for stmt in file.stmts() { + if let ast::Stmt::DropDatabase(drop_database) = stmt { ctx.report(Violation::new( Rule::BanDropDatabase, "Dropping a database may break existing clients.".into(), diff --git a/crates/squawk_linter/src/rules/ban_drop_not_null.rs b/crates/squawk_linter/src/rules/ban_drop_not_null.rs index 1de56297..49bda243 100644 --- a/crates/squawk_linter/src/rules/ban_drop_not_null.rs +++ b/crates/squawk_linter/src/rules/ban_drop_not_null.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -7,8 +7,8 @@ use crate::{Linter, Rule, Violation}; pub(crate) fn ban_drop_not_null(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::AlterTable(alter_table) = item { + for stmt in file.stmts() { + if let ast::Stmt::AlterTable(alter_table) = stmt { for action in alter_table.actions() { if let ast::AlterTableAction::AlterColumn(alter_column) = action { if let Some(ast::AlterColumnOption::DropNotNull(drop_not_null)) = diff --git a/crates/squawk_linter/src/rules/ban_drop_table.rs b/crates/squawk_linter/src/rules/ban_drop_table.rs index 1344f8a2..7cab303d 100644 --- a/crates/squawk_linter/src/rules/ban_drop_table.rs +++ b/crates/squawk_linter/src/rules/ban_drop_table.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -7,8 +7,8 @@ use crate::{Linter, Rule, Violation}; pub(crate) fn ban_drop_table(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::DropTable(drop_table) = item { + for stmt in file.stmts() { + if let ast::Stmt::DropTable(drop_table) = stmt { ctx.report(Violation::new( Rule::BanDropTable, "Dropping a table may break existing clients.".into(), diff --git a/crates/squawk_linter/src/rules/ban_truncate_cascade.rs b/crates/squawk_linter/src/rules/ban_truncate_cascade.rs index 8954bcb3..456d8982 100644 --- a/crates/squawk_linter/src/rules/ban_truncate_cascade.rs +++ b/crates/squawk_linter/src/rules/ban_truncate_cascade.rs @@ -1,14 +1,11 @@ -use squawk_syntax::{ - ast::{self, HasModuleItem}, - Parse, SourceFile, -}; +use squawk_syntax::{ast, Parse, SourceFile}; use crate::{Linter, Rule, Violation}; pub(crate) fn ban_truncate_cascade(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - match item { + for stmt in file.stmts() { + match stmt { ast::Stmt::Truncate(truncate) => { if let Some(cascade) = truncate.cascade_token() { // TODO: if we had knowledge about the entire schema, we diff --git a/crates/squawk_linter/src/rules/changing_column_type.rs b/crates/squawk_linter/src/rules/changing_column_type.rs index 32eacb34..6df2c8da 100644 --- a/crates/squawk_linter/src/rules/changing_column_type.rs +++ b/crates/squawk_linter/src/rules/changing_column_type.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -7,8 +7,8 @@ use crate::{Linter, Rule, Violation}; pub(crate) fn changing_column_type(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::AlterTable(alter_table) = item { + for stmt in file.stmts() { + if let ast::Stmt::AlterTable(alter_table) = stmt { for action in alter_table.actions() { if let ast::AlterTableAction::AlterColumn(alter_column) = action { if let Some(ast::AlterColumnOption::SetType(set_type)) = alter_column.option() { diff --git a/crates/squawk_linter/src/rules/constraint_missing_not_valid.rs b/crates/squawk_linter/src/rules/constraint_missing_not_valid.rs index 05e506b2..f06527af 100644 --- a/crates/squawk_linter/src/rules/constraint_missing_not_valid.rs +++ b/crates/squawk_linter/src/rules/constraint_missing_not_valid.rs @@ -1,7 +1,7 @@ use std::collections::HashSet; use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -13,8 +13,8 @@ pub fn tables_created_in_transaction( ) -> HashSet { let mut created_table_names = HashSet::new(); let mut inside_transaction = assume_in_transaction; - for item in file.items() { - match item { + for stmt in file.stmts() { + match stmt { ast::Stmt::Begin(_) => { inside_transaction = true; } @@ -44,8 +44,8 @@ fn not_valid_validate_in_transaction( ) { let mut inside_transaction = assume_in_transaction; let mut not_valid_names: HashSet = HashSet::new(); - for item in file.items() { - match item { + for stmt in file.stmts() { + match stmt { ast::Stmt::AlterTable(alter_table) => { for action in alter_table.actions() { match action { @@ -104,8 +104,8 @@ pub(crate) fn constraint_missing_not_valid(ctx: &mut Linter, parse: &Parse) { let mut constraint_names: HashMap = HashMap::new(); let mut total_stmts = 0; - for _ in file.items() { + for _ in file.stmts() { total_stmts += 1; if total_stmts > 1 { break; @@ -36,8 +36,8 @@ pub(crate) fn prefer_robust_stmts(ctx: &mut Linter, parse: &Parse) { None, } - for item in file.items() { - match item { + for stmt in file.stmts() { + match stmt { ast::Stmt::Begin(_) => { inside_transaction = true; } diff --git a/crates/squawk_linter/src/rules/renaming_column.rs b/crates/squawk_linter/src/rules/renaming_column.rs index 243e9f0e..5b3d0d55 100644 --- a/crates/squawk_linter/src/rules/renaming_column.rs +++ b/crates/squawk_linter/src/rules/renaming_column.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -7,8 +7,8 @@ use crate::{Linter, Rule, Violation}; pub(crate) fn renaming_column(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::AlterTable(alter_table) = item { + for stmt in file.stmts() { + if let ast::Stmt::AlterTable(alter_table) = stmt { for action in alter_table.actions() { if let ast::AlterTableAction::RenameColumn(rename_column) = action { ctx.report(Violation::new( diff --git a/crates/squawk_linter/src/rules/renaming_table.rs b/crates/squawk_linter/src/rules/renaming_table.rs index 8caf9a8d..46a59081 100644 --- a/crates/squawk_linter/src/rules/renaming_table.rs +++ b/crates/squawk_linter/src/rules/renaming_table.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -7,8 +7,8 @@ use crate::{Linter, Rule, Violation}; pub(crate) fn renaming_table(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::AlterTable(alter_table) = item { + for stmt in file.stmts() { + if let ast::Stmt::AlterTable(alter_table) = stmt { for action in alter_table.actions() { if let ast::AlterTableAction::RenameTable(rename_table) = action { ctx.report(Violation::new( diff --git a/crates/squawk_linter/src/rules/require_concurrent_index_creation.rs b/crates/squawk_linter/src/rules/require_concurrent_index_creation.rs index 06b62302..ce2c9446 100644 --- a/crates/squawk_linter/src/rules/require_concurrent_index_creation.rs +++ b/crates/squawk_linter/src/rules/require_concurrent_index_creation.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -10,8 +10,8 @@ use super::constraint_missing_not_valid::tables_created_in_transaction; pub(crate) fn require_concurrent_index_creation(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); let tables_created = tables_created_in_transaction(ctx.settings.assume_in_transaction, &file); - for item in file.items() { - if let ast::Stmt::CreateIndex(create_index) = item { + for stmt in file.stmts() { + if let ast::Stmt::CreateIndex(create_index) = stmt { if let Some(table_name) = create_index .path() .and_then(|x| x.segment()) diff --git a/crates/squawk_linter/src/rules/require_concurrent_index_deletion.rs b/crates/squawk_linter/src/rules/require_concurrent_index_deletion.rs index 7180af10..77cb4ecb 100644 --- a/crates/squawk_linter/src/rules/require_concurrent_index_deletion.rs +++ b/crates/squawk_linter/src/rules/require_concurrent_index_deletion.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -7,8 +7,8 @@ use crate::{Linter, Rule, Violation}; pub(crate) fn require_concurrent_index_deletion(ctx: &mut Linter, parse: &Parse) { let file = parse.tree(); - for item in file.items() { - if let ast::Stmt::DropIndex(drop_index) = item { + for stmt in file.stmts() { + if let ast::Stmt::DropIndex(drop_index) = stmt { if drop_index.concurrently_token().is_none() { ctx.report(Violation::new( Rule::RequireConcurrentIndexDeletion, diff --git a/crates/squawk_linter/src/rules/transaction_nesting.rs b/crates/squawk_linter/src/rules/transaction_nesting.rs index b3abc7d9..597e7e2e 100644 --- a/crates/squawk_linter/src/rules/transaction_nesting.rs +++ b/crates/squawk_linter/src/rules/transaction_nesting.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasModuleItem}, + ast::{self, AstNode}, Parse, SourceFile, }; @@ -10,8 +10,8 @@ pub(crate) fn transaction_nesting(ctx: &mut Linter, parse: &Parse) { let mut in_explicit_transaction = false; let assume_in_transaction_help = "Put migration statements in separate files to have them be in separate transactions or don't use the assume-in-transaction setting."; - for item in file.items() { - match item { + for stmt in file.stmts() { + match stmt { ast::Stmt::Begin(_) => { if ctx.settings.assume_in_transaction { ctx.report(Violation::new( diff --git a/crates/squawk_linter/src/visitors.rs b/crates/squawk_linter/src/visitors.rs index 2d642e6b..c4d5b979 100644 --- a/crates/squawk_linter/src/visitors.rs +++ b/crates/squawk_linter/src/visitors.rs @@ -1,6 +1,6 @@ use std::collections::HashSet; -use squawk_syntax::ast::{self, HasModuleItem}; +use squawk_syntax::ast; use crate::{text::trim_quotes, Linter}; @@ -39,12 +39,12 @@ pub(crate) fn check_not_allowed_types( file: &ast::SourceFile, check_ty: impl Fn(&mut Linter, Option), ) { - for item in file.items() { - match item { + for stmt in file.stmts() { + match stmt { ast::Stmt::CreateTable(create_table) => { if let Some(table_args) = create_table.table_args() { for arg in table_args.args() { - if let ast::TableArg::Column(column) = arg { + if let ast::TableArgs::Column(column) = arg { check_ty(ctx, column.ty()); } } diff --git a/crates/squawk_parser/src/generated/mod.rs b/crates/squawk_parser/src/generated/mod.rs new file mode 100644 index 00000000..807d31d4 --- /dev/null +++ b/crates/squawk_parser/src/generated/mod.rs @@ -0,0 +1,2 @@ +pub mod syntax_kind; +pub(crate) mod token_sets; diff --git a/crates/squawk_parser/src/generated/syntax_kind.rs b/crates/squawk_parser/src/generated/syntax_kind.rs new file mode 100644 index 00000000..1588370f --- /dev/null +++ b/crates/squawk_parser/src/generated/syntax_kind.rs @@ -0,0 +1,1959 @@ +#![allow(bad_style, missing_docs, clippy::upper_case_acronyms)] +#[doc = r"The kind of syntax node, e.g. `IDENT`, `SELECT_KW`, or `WHERE_CLAUSE`. Needs to be compatible with [`rowan::SyntaxKind`]"] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] +#[repr(u16)] +pub enum SyntaxKind { + #[doc(hidden)] + TOMBSTONE, + #[doc(hidden)] + EOF, + DOLLAR, + SEMICOLON, + COMMA, + L_PAREN, + R_PAREN, + L_BRACK, + R_BRACK, + L_ANGLE, + R_ANGLE, + AT, + POUND, + TILDE, + QUESTION, + AMP, + PIPE, + PLUS, + STAR, + SLASH, + CARET, + PERCENT, + UNDERSCORE, + DOT, + COLON, + EQ, + BANG, + MINUS, + BACKTICK, + ABORT_KW, + ABSENT_KW, + ABSOLUTE_KW, + ACCESS_KW, + ACTION_KW, + ADD_KW, + ADMIN_KW, + AFTER_KW, + AGGREGATE_KW, + ALL_KW, + ALSO_KW, + ALTER_KW, + ALWAYS_KW, + ANALYSE_KW, + ANALYZE_KW, + AND_KW, + ANY_KW, + ARRAY_KW, + AS_KW, + ASC_KW, + ASENSITIVE_KW, + ASSERTION_KW, + ASSIGNMENT_KW, + ASYMMETRIC_KW, + AT_KW, + ATOMIC_KW, + ATTACH_KW, + ATTRIBUTE_KW, + AUTHORIZATION_KW, + BACKWARD_KW, + BEFORE_KW, + BEGIN_KW, + BETWEEN_KW, + BIGINT_KW, + BINARY_KW, + BIT_KW, + BOOLEAN_KW, + BOTH_KW, + BREADTH_KW, + BY_KW, + CACHE_KW, + CALL_KW, + CALLED_KW, + CASCADE_KW, + CASCADED_KW, + CASE_KW, + CAST_KW, + CATALOG_KW, + CHAIN_KW, + CHAR_KW, + CHARACTER_KW, + CHARACTERISTICS_KW, + CHECK_KW, + CHECKPOINT_KW, + CLASS_KW, + CLOSE_KW, + CLUSTER_KW, + COALESCE_KW, + COLLATE_KW, + COLLATION_KW, + COLUMN_KW, + COLUMNS_KW, + COMMENT_KW, + COMMENTS_KW, + COMMIT_KW, + COMMITTED_KW, + COMPRESSION_KW, + CONCURRENTLY_KW, + CONDITIONAL_KW, + CONFIGURATION_KW, + CONFLICT_KW, + CONNECTION_KW, + CONSTRAINT_KW, + CONSTRAINTS_KW, + CONTENT_KW, + CONTINUE_KW, + CONVERSION_KW, + COPY_KW, + COST_KW, + CREATE_KW, + CROSS_KW, + CSV_KW, + CUBE_KW, + CURRENT_KW, + CURRENT_CATALOG_KW, + CURRENT_DATE_KW, + CURRENT_ROLE_KW, + CURRENT_SCHEMA_KW, + CURRENT_TIME_KW, + CURRENT_TIMESTAMP_KW, + CURRENT_USER_KW, + CURSOR_KW, + CYCLE_KW, + DATA_KW, + DATABASE_KW, + DAY_KW, + DEALLOCATE_KW, + DEC_KW, + DECIMAL_KW, + DECLARE_KW, + DEFAULT_KW, + DEFAULTS_KW, + DEFERRABLE_KW, + DEFERRED_KW, + DEFINER_KW, + DELETE_KW, + DELIMITER_KW, + DELIMITERS_KW, + DEPENDS_KW, + DEPTH_KW, + DESC_KW, + DETACH_KW, + DICTIONARY_KW, + DISABLE_KW, + DISCARD_KW, + DISTINCT_KW, + DO_KW, + DOCUMENT_KW, + DOMAIN_KW, + DOUBLE_KW, + DROP_KW, + EACH_KW, + ELSE_KW, + EMPTY_KW, + ENABLE_KW, + ENCODING_KW, + ENCRYPTED_KW, + END_KW, + ENUM_KW, + ERROR_KW, + ESCAPE_KW, + EVENT_KW, + EXCEPT_KW, + EXCLUDE_KW, + EXCLUDING_KW, + EXCLUSIVE_KW, + EXECUTE_KW, + EXISTS_KW, + EXPLAIN_KW, + EXPRESSION_KW, + EXTENSION_KW, + EXTERNAL_KW, + EXTRACT_KW, + FALSE_KW, + FAMILY_KW, + FETCH_KW, + FILTER_KW, + FINALIZE_KW, + FIRST_KW, + FLOAT_KW, + FOLLOWING_KW, + FOR_KW, + FORCE_KW, + FOREIGN_KW, + FORMAT_KW, + FORWARD_KW, + FREEZE_KW, + FROM_KW, + FULL_KW, + FUNCTION_KW, + FUNCTIONS_KW, + GENERATED_KW, + GLOBAL_KW, + GRANT_KW, + GRANTED_KW, + GREATEST_KW, + GROUP_KW, + GROUPING_KW, + GROUPS_KW, + HANDLER_KW, + HAVING_KW, + HEADER_KW, + HOLD_KW, + HOUR_KW, + IDENTITY_KW, + IF_KW, + ILIKE_KW, + IMMEDIATE_KW, + IMMUTABLE_KW, + IMPLICIT_KW, + IMPORT_KW, + IN_KW, + INCLUDE_KW, + INCLUDING_KW, + INCREMENT_KW, + INDENT_KW, + INDEX_KW, + INDEXES_KW, + INHERIT_KW, + INHERITS_KW, + INITIALLY_KW, + INLINE_KW, + INNER_KW, + INOUT_KW, + INPUT_KW, + INSENSITIVE_KW, + INSERT_KW, + INSTEAD_KW, + INT_KW, + INTEGER_KW, + INTERSECT_KW, + INTERVAL_KW, + INTO_KW, + INVOKER_KW, + IS_KW, + ISNULL_KW, + ISOLATION_KW, + JOIN_KW, + JSON_KW, + JSON_ARRAY_KW, + JSON_ARRAYAGG_KW, + JSON_EXISTS_KW, + JSON_OBJECT_KW, + JSON_OBJECTAGG_KW, + JSON_QUERY_KW, + JSON_SCALAR_KW, + JSON_SERIALIZE_KW, + JSON_TABLE_KW, + JSON_VALUE_KW, + KEEP_KW, + KEY_KW, + KEYS_KW, + LABEL_KW, + LANGUAGE_KW, + LARGE_KW, + LAST_KW, + LATERAL_KW, + LEADING_KW, + LEAKPROOF_KW, + LEAST_KW, + LEFT_KW, + LEVEL_KW, + LIKE_KW, + LIMIT_KW, + LISTEN_KW, + LOAD_KW, + LOCAL_KW, + LOCALTIME_KW, + LOCALTIMESTAMP_KW, + LOCATION_KW, + LOCK_KW, + LOCKED_KW, + LOGGED_KW, + MAPPING_KW, + MATCH_KW, + MATCHED_KW, + MATERIALIZED_KW, + MAXVALUE_KW, + MERGE_KW, + MERGE_ACTION_KW, + METHOD_KW, + MINUTE_KW, + MINVALUE_KW, + MODE_KW, + MONTH_KW, + MOVE_KW, + NAME_KW, + NAMES_KW, + NATIONAL_KW, + NATURAL_KW, + NCHAR_KW, + NESTED_KW, + NEW_KW, + NEXT_KW, + NFC_KW, + NFD_KW, + NFKC_KW, + NFKD_KW, + NO_KW, + NONE_KW, + NORMALIZE_KW, + NORMALIZED_KW, + NOT_KW, + NOTHING_KW, + NOTIFY_KW, + NOTNULL_KW, + NOWAIT_KW, + NULL_KW, + NULLIF_KW, + NULLS_KW, + NUMERIC_KW, + OBJECT_KW, + OF_KW, + OFF_KW, + OFFSET_KW, + OIDS_KW, + OLD_KW, + OMIT_KW, + ON_KW, + ONLY_KW, + OPERATOR_KW, + OPTION_KW, + OPTIONS_KW, + OR_KW, + ORDER_KW, + ORDINALITY_KW, + OTHERS_KW, + OUT_KW, + OUTER_KW, + OVER_KW, + OVERLAPS_KW, + OVERLAY_KW, + OVERRIDING_KW, + OWNED_KW, + OWNER_KW, + PARALLEL_KW, + PARAMETER_KW, + PARSER_KW, + PARTIAL_KW, + PARTITION_KW, + PASSING_KW, + PASSWORD_KW, + PATH_KW, + PERIOD_KW, + PLACING_KW, + PLAN_KW, + PLANS_KW, + POLICY_KW, + POSITION_KW, + PRECEDING_KW, + PRECISION_KW, + PREPARE_KW, + PREPARED_KW, + PRESERVE_KW, + PRIMARY_KW, + PRIOR_KW, + PRIVILEGES_KW, + PROCEDURAL_KW, + PROCEDURE_KW, + PROCEDURES_KW, + PROGRAM_KW, + PUBLICATION_KW, + QUOTE_KW, + QUOTES_KW, + RANGE_KW, + READ_KW, + REAL_KW, + REASSIGN_KW, + RECURSIVE_KW, + REF_KW, + REFERENCES_KW, + REFERENCING_KW, + REFRESH_KW, + REINDEX_KW, + RELATIVE_KW, + RELEASE_KW, + RENAME_KW, + REPEATABLE_KW, + REPLACE_KW, + REPLICA_KW, + RESET_KW, + RESTART_KW, + RESTRICT_KW, + RESTRICTED_KW, + RETURN_KW, + RETURNING_KW, + RETURNS_KW, + REVOKE_KW, + RIGHT_KW, + ROLE_KW, + ROLLBACK_KW, + ROLLUP_KW, + ROUTINE_KW, + ROUTINES_KW, + ROW_KW, + ROWS_KW, + RULE_KW, + SAFE_KW, + SAVEPOINT_KW, + SCALAR_KW, + SCHEMA_KW, + SCHEMAS_KW, + SCROLL_KW, + SEARCH_KW, + SECOND_KW, + SECURITY_KW, + SELECT_KW, + SEQUENCE_KW, + SEQUENCES_KW, + SERIALIZABLE_KW, + SERVER_KW, + SESSION_KW, + SESSION_USER_KW, + SET_KW, + SETOF_KW, + SETS_KW, + SHARE_KW, + SHOW_KW, + SIMILAR_KW, + SIMPLE_KW, + SKIP_KW, + SMALLINT_KW, + SNAPSHOT_KW, + SOME_KW, + SOURCE_KW, + SQL_KW, + STABLE_KW, + STANDALONE_KW, + START_KW, + STATEMENT_KW, + STATISTICS_KW, + STDIN_KW, + STDOUT_KW, + STORAGE_KW, + STORED_KW, + STRICT_KW, + STRING_KW, + STRIP_KW, + SUBSCRIPTION_KW, + SUBSTRING_KW, + SUPPORT_KW, + SYMMETRIC_KW, + SYSID_KW, + SYSTEM_KW, + SYSTEM_USER_KW, + TABLE_KW, + TABLES_KW, + TABLESAMPLE_KW, + TABLESPACE_KW, + TARGET_KW, + TEMP_KW, + TEMPLATE_KW, + TEMPORARY_KW, + TEXT_KW, + THEN_KW, + TIES_KW, + TIME_KW, + TIMESTAMP_KW, + TO_KW, + TRAILING_KW, + TRANSACTION_KW, + TRANSFORM_KW, + TREAT_KW, + TRIGGER_KW, + TRIM_KW, + TRUE_KW, + TRUNCATE_KW, + TRUSTED_KW, + TYPE_KW, + TYPES_KW, + UESCAPE_KW, + UNBOUNDED_KW, + UNCOMMITTED_KW, + UNCONDITIONAL_KW, + UNENCRYPTED_KW, + UNION_KW, + UNIQUE_KW, + UNKNOWN_KW, + UNLISTEN_KW, + UNLOGGED_KW, + UNSAFE_KW, + UNTIL_KW, + UPDATE_KW, + USER_KW, + USING_KW, + VACUUM_KW, + VALID_KW, + VALIDATE_KW, + VALIDATOR_KW, + VALUE_KW, + VALUES_KW, + VARCHAR_KW, + VARIADIC_KW, + VARYING_KW, + VERBOSE_KW, + VERSION_KW, + VIEW_KW, + VIEWS_KW, + VOLATILE_KW, + WHEN_KW, + WHERE_KW, + WHITESPACE_KW, + WINDOW_KW, + WITH_KW, + WITHIN_KW, + WITHOUT_KW, + WORK_KW, + WRAPPER_KW, + WRITE_KW, + XML_KW, + XMLATTRIBUTES_KW, + XMLCONCAT_KW, + XMLELEMENT_KW, + XMLEXISTS_KW, + XMLFOREST_KW, + XMLNAMESPACES_KW, + XMLPARSE_KW, + XMLPI_KW, + XMLROOT_KW, + XMLSERIALIZE_KW, + XMLTABLE_KW, + YEAR_KW, + YES_KW, + ZONE_KW, + BIT_STRING, + BYTE_STRING, + DOLLAR_QUOTED_STRING, + ESC_STRING, + FLOAT_NUMBER, + INT_NUMBER, + NULL, + POSITIONAL_PARAM, + STRING, + COMMENT, + ERROR, + IDENT, + WHITESPACE, + ADD_COLUMN, + ADD_CONSTRAINT, + ADD_GENERATED, + ALIAS, + ALTER_AGGREGATE, + ALTER_AGGREGATE_STMT, + ALTER_COLLATION_STMT, + ALTER_COLUMN, + ALTER_CONSTRAINT, + ALTER_CONVERSION_STMT, + ALTER_DATABASE_STMT, + ALTER_DEFAULT_PRIVILEGES_STMT, + ALTER_DOMAIN, + ALTER_DOMAIN_ACTION, + ALTER_DOMAIN_STMT, + ALTER_EVENT_TRIGGER_STMT, + ALTER_EXTENSION_STMT, + ALTER_FOREIGN_DATA_WRAPPER_STMT, + ALTER_FOREIGN_TABLE_STMT, + ALTER_FUNCTION_STMT, + ALTER_GROUP_STMT, + ALTER_INDEX_STMT, + ALTER_LANGUAGE_STMT, + ALTER_LARGE_OBJECT_STMT, + ALTER_MATERIALIZED_VIEW_STMT, + ALTER_OPERATOR_CLASS_STMT, + ALTER_OPERATOR_FAMILY_STMT, + ALTER_OPERATOR_STMT, + ALTER_POLICY_STMT, + ALTER_PROCEDURE_STMT, + ALTER_PUBLICATION_STMT, + ALTER_ROLE_STMT, + ALTER_ROUTINE_STMT, + ALTER_RULE_STMT, + ALTER_SCHEMA_STMT, + ALTER_SEQUENCE_STMT, + ALTER_SERVER_STMT, + ALTER_STATISTICS_STMT, + ALTER_SUBSCRIPTION_STMT, + ALTER_SYSTEM_STMT, + ALTER_TABLE, + ALTER_TABLESPACE_STMT, + ALTER_TABLE_ACTION, + ALTER_TEXT_SEARCH_CONFIGURATION_STMT, + ALTER_TEXT_SEARCH_DICTIONARY_STMT, + ALTER_TEXT_SEARCH_PARSER_STMT, + ALTER_TEXT_SEARCH_TEMPLATE_STMT, + ALTER_TRIGGER_STMT, + ALTER_TYPE_STMT, + ALTER_USER_MAPPING_STMT, + ALTER_USER_STMT, + ALTER_VIEW_STMT, + ANALYZE_STMT, + ARG, + ARG_LIST, + ARRAY_EXPR, + ARRAY_TYPE, + AS_FUNC_OPTION, + ATTACH_PARTITION, + AT_TIME_ZONE, + BEGIN, + BEGIN_FUNC_OPTION, + BETWEEN_EXPR, + BIN_EXPR, + BIT_TYPE, + CALL_EXPR, + CALL_STMT, + CASE_EXPR, + CAST_EXPR, + CHAR_TYPE, + CHECKPOINT_STMT, + CHECK_CONSTRAINT, + CLOSE_STMT, + CLUSTER_ON, + CLUSTER_STMT, + COLLATE, + COLON_COLON, + COLON_EQ, + COLUMN, + COLUMN_LIST, + COMMENT_STMT, + COMMIT, + COMPOUND_SELECT, + CONSTRAINT, + CONSTRAINT_EXCLUSIONS, + CONSTRAINT_INCLUDE_CLAUSE, + CONSTRAINT_INDEX_METHOD, + CONSTRAINT_INDEX_TABLESPACE, + CONSTRAINT_OPTION_LIST, + CONSTRAINT_STORAGE_PARAMS, + CONSTRAINT_WHERE_CLAUSE, + COPY_STMT, + COST_FUNC_OPTION, + CREATE_ACCESS_METHOD_STMT, + CREATE_AGGREGATE, + CREATE_AGGREGATE_STMT, + CREATE_CAST_STMT, + CREATE_COLLATION_STMT, + CREATE_CONVERSION_STMT, + CREATE_DATABASE_STMT, + CREATE_DOMAIN, + CREATE_DOMAIN_STMT, + CREATE_EVENT_TRIGGER_STMT, + CREATE_EXTENSION_STMT, + CREATE_FOREIGN_DATA_WRAPPER_STMT, + CREATE_FOREIGN_TABLE_STMT, + CREATE_FUNC, + CREATE_FUNCTION_STMT, + CREATE_GROUP_STMT, + CREATE_INDEX, + CREATE_LANGUAGE_STMT, + CREATE_MATERIALIZED_VIEW_STMT, + CREATE_OPERATOR_CLASS_STMT, + CREATE_OPERATOR_FAMILY_STMT, + CREATE_OPERATOR_STMT, + CREATE_POLICY_STMT, + CREATE_PROCEDURE_STMT, + CREATE_PUBLICATION_STMT, + CREATE_ROLE_STMT, + CREATE_RULE_STMT, + CREATE_SCHEMA_STMT, + CREATE_SEQUENCE_STMT, + CREATE_SERVER_STMT, + CREATE_STATISTICS_STMT, + CREATE_SUBSCRIPTION_STMT, + CREATE_TABLE, + CREATE_TABLESPACE_STMT, + CREATE_TABLE_AS_STMT, + CREATE_TEXT_SEARCH_CONFIGURATION_STMT, + CREATE_TEXT_SEARCH_DICTIONARY_STMT, + CREATE_TEXT_SEARCH_PARSER_STMT, + CREATE_TEXT_SEARCH_TEMPLATE_STMT, + CREATE_TRANSFORM_STMT, + CREATE_TRIGGER_STMT, + CREATE_TYPE_STMT, + CREATE_USER_MAPPING_STMT, + CREATE_USER_STMT, + CREATE_VIEW_STMT, + CUSTOM_OP, + DEALLOCATE_STMT, + DECLARE_STMT, + DEFAULT_CONSTRAINT, + DEFERRABLE, + DEFERRABLE_CONSTRAINT_OPTION, + DELETE_STMT, + DETACH_PARTITION, + DISABLE_RLS, + DISABLE_RULE, + DISABLE_TRIGGER, + DISCARD_STMT, + DISTINCT_CLAUSE, + DOUBLE_TYPE, + DO_STMT, + DROP_ACCESS_METHOD_STMT, + DROP_AGGREGATE, + DROP_CAST_STMT, + DROP_COLLATION_STMT, + DROP_COLUMN, + DROP_CONSTRAINT, + DROP_CONVERSION_STMT, + DROP_DATABASE, + DROP_DATABASE_STMT, + DROP_DEFAULT, + DROP_DOMAIN_STMT, + DROP_EVENT_TRIGGER_STMT, + DROP_EXPRESSION, + DROP_EXTENSION_STMT, + DROP_FOREIGN_DATA_WRAPPER_STMT, + DROP_FOREIGN_TABLE_STMT, + DROP_FUNCTION_STMT, + DROP_GROUP_STMT, + DROP_IDENTITY, + DROP_INDEX, + DROP_INDEX_STMT, + DROP_LANGUAGE_STMT, + DROP_MATERIALIZED_VIEW_STMT, + DROP_NOT_NULL, + DROP_OPERATOR_CLASS_STMT, + DROP_OPERATOR_FAMILY_STMT, + DROP_OPERATOR_STMT, + DROP_OWNED_STMT, + DROP_POLICY_STMT, + DROP_PROCEDURE_STMT, + DROP_PUBLICATION_STMT, + DROP_ROLE_STMT, + DROP_ROUTINE_STMT, + DROP_RULE_STMT, + DROP_SCHEMA_STMT, + DROP_SEQUENCE_STMT, + DROP_SERVER_STMT, + DROP_STATISTICS_STMT, + DROP_SUBSCRIPTION_STMT, + DROP_TABLE, + DROP_TABLESPACE_STMT, + DROP_TEXT_SEARCH_CONFIG_STMT, + DROP_TEXT_SEARCH_DICT_STMT, + DROP_TEXT_SEARCH_PARSER_STMT, + DROP_TEXT_SEARCH_TEMPLATE_STMT, + DROP_TRANSFORM_STMT, + DROP_TRIGGER_STMT, + DROP_TYPE, + DROP_TYPE_STMT, + DROP_USER_MAPPING_STMT, + DROP_USER_STMT, + DROP_VIEW_STMT, + ENABLE_ALWAYS_RULE, + ENABLE_ALWAYS_TRIGGER, + ENABLE_REPLICA_RULE, + ENABLE_REPLICA_TRIGGER, + ENABLE_RLS, + ENABLE_RULE, + ENABLE_TRIGGER, + EXCLUDE_CONSTRAINT, + EXECUTE_STMT, + EXPLAIN_STMT, + EXPR, + FAT_ARROW, + FETCH_STMT, + FIELD_EXPR, + FILTER_CLAUSE, + FORCE_RLS, + FOREIGN_KEY_CONSTRAINT, + FROM_CLAUSE, + FUNC_OPTION, + FUNC_OPTION_LIST, + GENERATED_CONSTRAINT, + GRANT_STMT, + GROUP_BY_CLAUSE, + GTEQ, + HAVING_CLAUSE, + IF_EXISTS, + IF_NOT_EXISTS, + IMPORT_FOREIGN_SCHEMA, + INDEX_EXPR, + INDEX_PARAMS, + INHERIT, + INITIALLY_DEFERRED_CONSTRAINT_OPTION, + INITIALLY_IMMEDIATE_CONSTRAINT_OPTION, + INSERT_STMT, + INTERVAL_TYPE, + INTO_CLAUSE, + IS_DISTINCT_FROM, + IS_NOT, + IS_NOT_DISTINCT_FROM, + IS_NULL, + JOIN, + JSON_BEHAVIOR_CLAUSE, + JSON_FORMAT_CLAUSE, + JSON_KEYS_UNIQUE_CLAUSE, + JSON_KEY_VALUE, + JSON_NULL_CLAUSE, + JSON_ON_ERROR_CLAUSE, + JSON_PASSING_CLAUSE, + JSON_QUOTES_CLAUSE, + JSON_RETURNING_CLAUSE, + JSON_VALUE_EXPR, + JSON_WRAPPER_BEHAVIOR_CLAUSE, + LANGUAGE_FUNC_OPTION, + LEAKPROOF_FUNC_OPTION, + LIKE_CLAUSE, + LIMIT_CLAUSE, + LISTEN_STMT, + LITERAL, + LOAD_STMT, + LOCKING_CLAUSE, + LOCK_STMT, + LTEQ, + MERGE_STMT, + MOVE_STMT, + NAME, + NAMED_ARG, + NAME_REF, + NEQ, + NEQB, + NOTIFY_STMT, + NOT_DEFERRABLE, + NOT_DEFERRABLE_CONSTRAINT_OPTION, + NOT_IN, + NOT_LIKE, + NOT_NULL_CONSTRAINT, + NOT_OF, + NOT_VALID, + NO_FORCE_RLS, + NO_INHERIT, + NULL_CONSTRAINT, + OFFSET_CLAUSE, + OF_TYPE, + OP, + OPERATOR_CALL, + ORDER_BY_CLAUSE, + OR_REPLACE, + OVER_CLAUSE, + OWNER_TO, + PARALLEL_FUNC_OPTION, + PARAM, + PARAM_DEFAULT, + PARAM_IN, + PARAM_IN_OUT, + PARAM_LIST, + PARAM_MODE, + PARAM_OUT, + PARAM_VARIADIC, + PAREN_EXPR, + PATH, + PATH_SEGMENT, + PATH_TYPE, + PERCENT_TYPE, + PERCENT_TYPE_CLAUSE, + POSTFIX_EXPR, + PREFIX_EXPR, + PREPARE_STMT, + PREPARE_TRANSACTION_STMT, + PRIMARY_KEY_CONSTRAINT, + READ_COMMITTED, + READ_ONLY, + READ_UNCOMMITTED, + READ_WRITE, + REASSIGN_STMT, + REFERENCES_CONSTRAINT, + REFRESH_STMT, + REINDEX_STMT, + RELATION_NAME, + RELEASE_SAVEPOINT_STMT, + RENAME_COLUMN, + RENAME_CONSTRAINT, + RENAME_TABLE, + RENAME_TO, + REPEATABLE_READ, + REPLICA_IDENTITY, + RESET_FUNC_OPTION, + RESET_OPTIONS, + RESET_STMT, + RESET_STORAGE_PARAMS, + RESTART, + RETURN_FUNC_OPTION, + RET_TYPE, + REVOKE_STMT, + ROLE, + ROLLBACK, + ROLLBACK_STMT, + ROWS_FUNC_OPTION, + SAVEPOINT_STMT, + SECURITY_FUNC_OPTION, + SECURITY_LABEL_STMT, + SELECT, + SELECT_CLAUSE, + SELECT_INTO_STMT, + SEQUENCE_OPTION_LIST, + SERIALIZABLE, + SET_ACCESS_METHOD, + SET_COMPRESSION, + SET_CONSTRAINTS_STMT, + SET_DEFAULT, + SET_EXPRESSION, + SET_FUNC_OPTION, + SET_GENERATED, + SET_GENERATED_OPTIONS, + SET_LOGGED, + SET_NOT_NULL, + SET_OPTIONS, + SET_OPTIONS_LIST, + SET_ROLE_STMT, + SET_SCHEMA, + SET_SEQUENCE_OPTION, + SET_SESSION_AUTH_STMT, + SET_STATISTICS, + SET_STMT, + SET_STORAGE, + SET_STORAGE_PARAMS, + SET_TABLESPACE, + SET_TRANSACTION_STMT, + SET_TYPE, + SET_UNLOGGED, + SET_WITHOUT_CLUSTER, + SET_WITHOUT_OIDS, + SHOW_STMT, + SIMILAR_TO, + SOURCE_FILE, + STMT, + STRICT_FUNC_OPTION, + SUPPORT_FUNC_OPTION, + TABLE_ARG, + TABLE_ARGS, + TABLE_CONSTRAINT, + TABLE_LIST, + TABLE_STMT, + TARGET, + TARGET_LIST, + TIME_TYPE, + TRANSACTION_MODE, + TRANSACTION_MODE_ISOLATION_LEVEL, + TRANSACTION_MODE_LIST, + TRANSFORM_FUNC_OPTION, + TRUNCATE_STMT, + TUPLE_EXPR, + TYPE, + UNIQUE_CONSTRAINT, + UNLISTEN_STMT, + UPDATE_STMT, + USING_CLAUSE, + USING_INDEX, + VACUUM_STMT, + VALIDATE_CONSTRAINT, + VALUES, + VOLATILITY_FUNC_OPTION, + WHEN_CLAUSE, + WHERE_CLAUSE, + WINDOW_CLAUSE, + WINDOW_DEF, + WINDOW_FUNC_OPTION, + WITHIN_CLAUSE, + WITHOUT_TIMEZONE, + WITH_CLAUSE, + WITH_TABLE, + WITH_TIMEZONE, + + #[doc(hidden)] + __LAST, +} + +impl SyntaxKind { + pub(crate) fn from_keyword(ident: &str) -> Option { + let kw = if ident.eq_ignore_ascii_case("abort") { + SyntaxKind::ABORT_KW + } else if ident.eq_ignore_ascii_case("absent") { + SyntaxKind::ABSENT_KW + } else if ident.eq_ignore_ascii_case("absolute") { + SyntaxKind::ABSOLUTE_KW + } else if ident.eq_ignore_ascii_case("access") { + SyntaxKind::ACCESS_KW + } else if ident.eq_ignore_ascii_case("action") { + SyntaxKind::ACTION_KW + } else if ident.eq_ignore_ascii_case("add") { + SyntaxKind::ADD_KW + } else if ident.eq_ignore_ascii_case("admin") { + SyntaxKind::ADMIN_KW + } else if ident.eq_ignore_ascii_case("after") { + SyntaxKind::AFTER_KW + } else if ident.eq_ignore_ascii_case("aggregate") { + SyntaxKind::AGGREGATE_KW + } else if ident.eq_ignore_ascii_case("all") { + SyntaxKind::ALL_KW + } else if ident.eq_ignore_ascii_case("also") { + SyntaxKind::ALSO_KW + } else if ident.eq_ignore_ascii_case("alter") { + SyntaxKind::ALTER_KW + } else if ident.eq_ignore_ascii_case("always") { + SyntaxKind::ALWAYS_KW + } else if ident.eq_ignore_ascii_case("analyse") { + SyntaxKind::ANALYSE_KW + } else if ident.eq_ignore_ascii_case("analyze") { + SyntaxKind::ANALYZE_KW + } else if ident.eq_ignore_ascii_case("and") { + SyntaxKind::AND_KW + } else if ident.eq_ignore_ascii_case("any") { + SyntaxKind::ANY_KW + } else if ident.eq_ignore_ascii_case("array") { + SyntaxKind::ARRAY_KW + } else if ident.eq_ignore_ascii_case("as") { + SyntaxKind::AS_KW + } else if ident.eq_ignore_ascii_case("asc") { + SyntaxKind::ASC_KW + } else if ident.eq_ignore_ascii_case("asensitive") { + SyntaxKind::ASENSITIVE_KW + } else if ident.eq_ignore_ascii_case("assertion") { + SyntaxKind::ASSERTION_KW + } else if ident.eq_ignore_ascii_case("assignment") { + SyntaxKind::ASSIGNMENT_KW + } else if ident.eq_ignore_ascii_case("asymmetric") { + SyntaxKind::ASYMMETRIC_KW + } else if ident.eq_ignore_ascii_case("at") { + SyntaxKind::AT_KW + } else if ident.eq_ignore_ascii_case("atomic") { + SyntaxKind::ATOMIC_KW + } else if ident.eq_ignore_ascii_case("attach") { + SyntaxKind::ATTACH_KW + } else if ident.eq_ignore_ascii_case("attribute") { + SyntaxKind::ATTRIBUTE_KW + } else if ident.eq_ignore_ascii_case("authorization") { + SyntaxKind::AUTHORIZATION_KW + } else if ident.eq_ignore_ascii_case("backward") { + SyntaxKind::BACKWARD_KW + } else if ident.eq_ignore_ascii_case("before") { + SyntaxKind::BEFORE_KW + } else if ident.eq_ignore_ascii_case("begin") { + SyntaxKind::BEGIN_KW + } else if ident.eq_ignore_ascii_case("between") { + SyntaxKind::BETWEEN_KW + } else if ident.eq_ignore_ascii_case("bigint") { + SyntaxKind::BIGINT_KW + } else if ident.eq_ignore_ascii_case("binary") { + SyntaxKind::BINARY_KW + } else if ident.eq_ignore_ascii_case("bit") { + SyntaxKind::BIT_KW + } else if ident.eq_ignore_ascii_case("boolean") { + SyntaxKind::BOOLEAN_KW + } else if ident.eq_ignore_ascii_case("both") { + SyntaxKind::BOTH_KW + } else if ident.eq_ignore_ascii_case("breadth") { + SyntaxKind::BREADTH_KW + } else if ident.eq_ignore_ascii_case("by") { + SyntaxKind::BY_KW + } else if ident.eq_ignore_ascii_case("cache") { + SyntaxKind::CACHE_KW + } else if ident.eq_ignore_ascii_case("call") { + SyntaxKind::CALL_KW + } else if ident.eq_ignore_ascii_case("called") { + SyntaxKind::CALLED_KW + } else if ident.eq_ignore_ascii_case("cascade") { + SyntaxKind::CASCADE_KW + } else if ident.eq_ignore_ascii_case("cascaded") { + SyntaxKind::CASCADED_KW + } else if ident.eq_ignore_ascii_case("case") { + SyntaxKind::CASE_KW + } else if ident.eq_ignore_ascii_case("cast") { + SyntaxKind::CAST_KW + } else if ident.eq_ignore_ascii_case("catalog") { + SyntaxKind::CATALOG_KW + } else if ident.eq_ignore_ascii_case("chain") { + SyntaxKind::CHAIN_KW + } else if ident.eq_ignore_ascii_case("char") { + SyntaxKind::CHAR_KW + } else if ident.eq_ignore_ascii_case("character") { + SyntaxKind::CHARACTER_KW + } else if ident.eq_ignore_ascii_case("characteristics") { + SyntaxKind::CHARACTERISTICS_KW + } else if ident.eq_ignore_ascii_case("check") { + SyntaxKind::CHECK_KW + } else if ident.eq_ignore_ascii_case("checkpoint") { + SyntaxKind::CHECKPOINT_KW + } else if ident.eq_ignore_ascii_case("class") { + SyntaxKind::CLASS_KW + } else if ident.eq_ignore_ascii_case("close") { + SyntaxKind::CLOSE_KW + } else if ident.eq_ignore_ascii_case("cluster") { + SyntaxKind::CLUSTER_KW + } else if ident.eq_ignore_ascii_case("coalesce") { + SyntaxKind::COALESCE_KW + } else if ident.eq_ignore_ascii_case("collate") { + SyntaxKind::COLLATE_KW + } else if ident.eq_ignore_ascii_case("collation") { + SyntaxKind::COLLATION_KW + } else if ident.eq_ignore_ascii_case("column") { + SyntaxKind::COLUMN_KW + } else if ident.eq_ignore_ascii_case("columns") { + SyntaxKind::COLUMNS_KW + } else if ident.eq_ignore_ascii_case("comment") { + SyntaxKind::COMMENT_KW + } else if ident.eq_ignore_ascii_case("comments") { + SyntaxKind::COMMENTS_KW + } else if ident.eq_ignore_ascii_case("commit") { + SyntaxKind::COMMIT_KW + } else if ident.eq_ignore_ascii_case("committed") { + SyntaxKind::COMMITTED_KW + } else if ident.eq_ignore_ascii_case("compression") { + SyntaxKind::COMPRESSION_KW + } else if ident.eq_ignore_ascii_case("concurrently") { + SyntaxKind::CONCURRENTLY_KW + } else if ident.eq_ignore_ascii_case("conditional") { + SyntaxKind::CONDITIONAL_KW + } else if ident.eq_ignore_ascii_case("configuration") { + SyntaxKind::CONFIGURATION_KW + } else if ident.eq_ignore_ascii_case("conflict") { + SyntaxKind::CONFLICT_KW + } else if ident.eq_ignore_ascii_case("connection") { + SyntaxKind::CONNECTION_KW + } else if ident.eq_ignore_ascii_case("constraint") { + SyntaxKind::CONSTRAINT_KW + } else if ident.eq_ignore_ascii_case("constraints") { + SyntaxKind::CONSTRAINTS_KW + } else if ident.eq_ignore_ascii_case("content") { + SyntaxKind::CONTENT_KW + } else if ident.eq_ignore_ascii_case("continue") { + SyntaxKind::CONTINUE_KW + } else if ident.eq_ignore_ascii_case("conversion") { + SyntaxKind::CONVERSION_KW + } else if ident.eq_ignore_ascii_case("copy") { + SyntaxKind::COPY_KW + } else if ident.eq_ignore_ascii_case("cost") { + SyntaxKind::COST_KW + } else if ident.eq_ignore_ascii_case("create") { + SyntaxKind::CREATE_KW + } else if ident.eq_ignore_ascii_case("cross") { + SyntaxKind::CROSS_KW + } else if ident.eq_ignore_ascii_case("csv") { + SyntaxKind::CSV_KW + } else if ident.eq_ignore_ascii_case("cube") { + SyntaxKind::CUBE_KW + } else if ident.eq_ignore_ascii_case("current") { + SyntaxKind::CURRENT_KW + } else if ident.eq_ignore_ascii_case("current_catalog") { + SyntaxKind::CURRENT_CATALOG_KW + } else if ident.eq_ignore_ascii_case("current_date") { + SyntaxKind::CURRENT_DATE_KW + } else if ident.eq_ignore_ascii_case("current_role") { + SyntaxKind::CURRENT_ROLE_KW + } else if ident.eq_ignore_ascii_case("current_schema") { + SyntaxKind::CURRENT_SCHEMA_KW + } else if ident.eq_ignore_ascii_case("current_time") { + SyntaxKind::CURRENT_TIME_KW + } else if ident.eq_ignore_ascii_case("current_timestamp") { + SyntaxKind::CURRENT_TIMESTAMP_KW + } else if ident.eq_ignore_ascii_case("current_user") { + SyntaxKind::CURRENT_USER_KW + } else if ident.eq_ignore_ascii_case("cursor") { + SyntaxKind::CURSOR_KW + } else if ident.eq_ignore_ascii_case("cycle") { + SyntaxKind::CYCLE_KW + } else if ident.eq_ignore_ascii_case("data") { + SyntaxKind::DATA_KW + } else if ident.eq_ignore_ascii_case("database") { + SyntaxKind::DATABASE_KW + } else if ident.eq_ignore_ascii_case("day") { + SyntaxKind::DAY_KW + } else if ident.eq_ignore_ascii_case("deallocate") { + SyntaxKind::DEALLOCATE_KW + } else if ident.eq_ignore_ascii_case("dec") { + SyntaxKind::DEC_KW + } else if ident.eq_ignore_ascii_case("decimal") { + SyntaxKind::DECIMAL_KW + } else if ident.eq_ignore_ascii_case("declare") { + SyntaxKind::DECLARE_KW + } else if ident.eq_ignore_ascii_case("default") { + SyntaxKind::DEFAULT_KW + } else if ident.eq_ignore_ascii_case("defaults") { + SyntaxKind::DEFAULTS_KW + } else if ident.eq_ignore_ascii_case("deferrable") { + SyntaxKind::DEFERRABLE_KW + } else if ident.eq_ignore_ascii_case("deferred") { + SyntaxKind::DEFERRED_KW + } else if ident.eq_ignore_ascii_case("definer") { + SyntaxKind::DEFINER_KW + } else if ident.eq_ignore_ascii_case("delete") { + SyntaxKind::DELETE_KW + } else if ident.eq_ignore_ascii_case("delimiter") { + SyntaxKind::DELIMITER_KW + } else if ident.eq_ignore_ascii_case("delimiters") { + SyntaxKind::DELIMITERS_KW + } else if ident.eq_ignore_ascii_case("depends") { + SyntaxKind::DEPENDS_KW + } else if ident.eq_ignore_ascii_case("depth") { + SyntaxKind::DEPTH_KW + } else if ident.eq_ignore_ascii_case("desc") { + SyntaxKind::DESC_KW + } else if ident.eq_ignore_ascii_case("detach") { + SyntaxKind::DETACH_KW + } else if ident.eq_ignore_ascii_case("dictionary") { + SyntaxKind::DICTIONARY_KW + } else if ident.eq_ignore_ascii_case("disable") { + SyntaxKind::DISABLE_KW + } else if ident.eq_ignore_ascii_case("discard") { + SyntaxKind::DISCARD_KW + } else if ident.eq_ignore_ascii_case("distinct") { + SyntaxKind::DISTINCT_KW + } else if ident.eq_ignore_ascii_case("do") { + SyntaxKind::DO_KW + } else if ident.eq_ignore_ascii_case("document") { + SyntaxKind::DOCUMENT_KW + } else if ident.eq_ignore_ascii_case("domain") { + SyntaxKind::DOMAIN_KW + } else if ident.eq_ignore_ascii_case("double") { + SyntaxKind::DOUBLE_KW + } else if ident.eq_ignore_ascii_case("drop") { + SyntaxKind::DROP_KW + } else if ident.eq_ignore_ascii_case("each") { + SyntaxKind::EACH_KW + } else if ident.eq_ignore_ascii_case("else") { + SyntaxKind::ELSE_KW + } else if ident.eq_ignore_ascii_case("empty") { + SyntaxKind::EMPTY_KW + } else if ident.eq_ignore_ascii_case("enable") { + SyntaxKind::ENABLE_KW + } else if ident.eq_ignore_ascii_case("encoding") { + SyntaxKind::ENCODING_KW + } else if ident.eq_ignore_ascii_case("encrypted") { + SyntaxKind::ENCRYPTED_KW + } else if ident.eq_ignore_ascii_case("end") { + SyntaxKind::END_KW + } else if ident.eq_ignore_ascii_case("enum") { + SyntaxKind::ENUM_KW + } else if ident.eq_ignore_ascii_case("error") { + SyntaxKind::ERROR_KW + } else if ident.eq_ignore_ascii_case("escape") { + SyntaxKind::ESCAPE_KW + } else if ident.eq_ignore_ascii_case("event") { + SyntaxKind::EVENT_KW + } else if ident.eq_ignore_ascii_case("except") { + SyntaxKind::EXCEPT_KW + } else if ident.eq_ignore_ascii_case("exclude") { + SyntaxKind::EXCLUDE_KW + } else if ident.eq_ignore_ascii_case("excluding") { + SyntaxKind::EXCLUDING_KW + } else if ident.eq_ignore_ascii_case("exclusive") { + SyntaxKind::EXCLUSIVE_KW + } else if ident.eq_ignore_ascii_case("execute") { + SyntaxKind::EXECUTE_KW + } else if ident.eq_ignore_ascii_case("exists") { + SyntaxKind::EXISTS_KW + } else if ident.eq_ignore_ascii_case("explain") { + SyntaxKind::EXPLAIN_KW + } else if ident.eq_ignore_ascii_case("expression") { + SyntaxKind::EXPRESSION_KW + } else if ident.eq_ignore_ascii_case("extension") { + SyntaxKind::EXTENSION_KW + } else if ident.eq_ignore_ascii_case("external") { + SyntaxKind::EXTERNAL_KW + } else if ident.eq_ignore_ascii_case("extract") { + SyntaxKind::EXTRACT_KW + } else if ident.eq_ignore_ascii_case("false") { + SyntaxKind::FALSE_KW + } else if ident.eq_ignore_ascii_case("family") { + SyntaxKind::FAMILY_KW + } else if ident.eq_ignore_ascii_case("fetch") { + SyntaxKind::FETCH_KW + } else if ident.eq_ignore_ascii_case("filter") { + SyntaxKind::FILTER_KW + } else if ident.eq_ignore_ascii_case("finalize") { + SyntaxKind::FINALIZE_KW + } else if ident.eq_ignore_ascii_case("first") { + SyntaxKind::FIRST_KW + } else if ident.eq_ignore_ascii_case("float") { + SyntaxKind::FLOAT_KW + } else if ident.eq_ignore_ascii_case("following") { + SyntaxKind::FOLLOWING_KW + } else if ident.eq_ignore_ascii_case("for") { + SyntaxKind::FOR_KW + } else if ident.eq_ignore_ascii_case("force") { + SyntaxKind::FORCE_KW + } else if ident.eq_ignore_ascii_case("foreign") { + SyntaxKind::FOREIGN_KW + } else if ident.eq_ignore_ascii_case("format") { + SyntaxKind::FORMAT_KW + } else if ident.eq_ignore_ascii_case("forward") { + SyntaxKind::FORWARD_KW + } else if ident.eq_ignore_ascii_case("freeze") { + SyntaxKind::FREEZE_KW + } else if ident.eq_ignore_ascii_case("from") { + SyntaxKind::FROM_KW + } else if ident.eq_ignore_ascii_case("full") { + SyntaxKind::FULL_KW + } else if ident.eq_ignore_ascii_case("function") { + SyntaxKind::FUNCTION_KW + } else if ident.eq_ignore_ascii_case("functions") { + SyntaxKind::FUNCTIONS_KW + } else if ident.eq_ignore_ascii_case("generated") { + SyntaxKind::GENERATED_KW + } else if ident.eq_ignore_ascii_case("global") { + SyntaxKind::GLOBAL_KW + } else if ident.eq_ignore_ascii_case("grant") { + SyntaxKind::GRANT_KW + } else if ident.eq_ignore_ascii_case("granted") { + SyntaxKind::GRANTED_KW + } else if ident.eq_ignore_ascii_case("greatest") { + SyntaxKind::GREATEST_KW + } else if ident.eq_ignore_ascii_case("group") { + SyntaxKind::GROUP_KW + } else if ident.eq_ignore_ascii_case("grouping") { + SyntaxKind::GROUPING_KW + } else if ident.eq_ignore_ascii_case("groups") { + SyntaxKind::GROUPS_KW + } else if ident.eq_ignore_ascii_case("handler") { + SyntaxKind::HANDLER_KW + } else if ident.eq_ignore_ascii_case("having") { + SyntaxKind::HAVING_KW + } else if ident.eq_ignore_ascii_case("header") { + SyntaxKind::HEADER_KW + } else if ident.eq_ignore_ascii_case("hold") { + SyntaxKind::HOLD_KW + } else if ident.eq_ignore_ascii_case("hour") { + SyntaxKind::HOUR_KW + } else if ident.eq_ignore_ascii_case("identity") { + SyntaxKind::IDENTITY_KW + } else if ident.eq_ignore_ascii_case("if") { + SyntaxKind::IF_KW + } else if ident.eq_ignore_ascii_case("ilike") { + SyntaxKind::ILIKE_KW + } else if ident.eq_ignore_ascii_case("immediate") { + SyntaxKind::IMMEDIATE_KW + } else if ident.eq_ignore_ascii_case("immutable") { + SyntaxKind::IMMUTABLE_KW + } else if ident.eq_ignore_ascii_case("implicit") { + SyntaxKind::IMPLICIT_KW + } else if ident.eq_ignore_ascii_case("import") { + SyntaxKind::IMPORT_KW + } else if ident.eq_ignore_ascii_case("in") { + SyntaxKind::IN_KW + } else if ident.eq_ignore_ascii_case("include") { + SyntaxKind::INCLUDE_KW + } else if ident.eq_ignore_ascii_case("including") { + SyntaxKind::INCLUDING_KW + } else if ident.eq_ignore_ascii_case("increment") { + SyntaxKind::INCREMENT_KW + } else if ident.eq_ignore_ascii_case("indent") { + SyntaxKind::INDENT_KW + } else if ident.eq_ignore_ascii_case("index") { + SyntaxKind::INDEX_KW + } else if ident.eq_ignore_ascii_case("indexes") { + SyntaxKind::INDEXES_KW + } else if ident.eq_ignore_ascii_case("inherit") { + SyntaxKind::INHERIT_KW + } else if ident.eq_ignore_ascii_case("inherits") { + SyntaxKind::INHERITS_KW + } else if ident.eq_ignore_ascii_case("initially") { + SyntaxKind::INITIALLY_KW + } else if ident.eq_ignore_ascii_case("inline") { + SyntaxKind::INLINE_KW + } else if ident.eq_ignore_ascii_case("inner") { + SyntaxKind::INNER_KW + } else if ident.eq_ignore_ascii_case("inout") { + SyntaxKind::INOUT_KW + } else if ident.eq_ignore_ascii_case("input") { + SyntaxKind::INPUT_KW + } else if ident.eq_ignore_ascii_case("insensitive") { + SyntaxKind::INSENSITIVE_KW + } else if ident.eq_ignore_ascii_case("insert") { + SyntaxKind::INSERT_KW + } else if ident.eq_ignore_ascii_case("instead") { + SyntaxKind::INSTEAD_KW + } else if ident.eq_ignore_ascii_case("int") { + SyntaxKind::INT_KW + } else if ident.eq_ignore_ascii_case("integer") { + SyntaxKind::INTEGER_KW + } else if ident.eq_ignore_ascii_case("intersect") { + SyntaxKind::INTERSECT_KW + } else if ident.eq_ignore_ascii_case("interval") { + SyntaxKind::INTERVAL_KW + } else if ident.eq_ignore_ascii_case("into") { + SyntaxKind::INTO_KW + } else if ident.eq_ignore_ascii_case("invoker") { + SyntaxKind::INVOKER_KW + } else if ident.eq_ignore_ascii_case("is") { + SyntaxKind::IS_KW + } else if ident.eq_ignore_ascii_case("isnull") { + SyntaxKind::ISNULL_KW + } else if ident.eq_ignore_ascii_case("isolation") { + SyntaxKind::ISOLATION_KW + } else if ident.eq_ignore_ascii_case("join") { + SyntaxKind::JOIN_KW + } else if ident.eq_ignore_ascii_case("json") { + SyntaxKind::JSON_KW + } else if ident.eq_ignore_ascii_case("json_array") { + SyntaxKind::JSON_ARRAY_KW + } else if ident.eq_ignore_ascii_case("json_arrayagg") { + SyntaxKind::JSON_ARRAYAGG_KW + } else if ident.eq_ignore_ascii_case("json_exists") { + SyntaxKind::JSON_EXISTS_KW + } else if ident.eq_ignore_ascii_case("json_object") { + SyntaxKind::JSON_OBJECT_KW + } else if ident.eq_ignore_ascii_case("json_objectagg") { + SyntaxKind::JSON_OBJECTAGG_KW + } else if ident.eq_ignore_ascii_case("json_query") { + SyntaxKind::JSON_QUERY_KW + } else if ident.eq_ignore_ascii_case("json_scalar") { + SyntaxKind::JSON_SCALAR_KW + } else if ident.eq_ignore_ascii_case("json_serialize") { + SyntaxKind::JSON_SERIALIZE_KW + } else if ident.eq_ignore_ascii_case("json_table") { + SyntaxKind::JSON_TABLE_KW + } else if ident.eq_ignore_ascii_case("json_value") { + SyntaxKind::JSON_VALUE_KW + } else if ident.eq_ignore_ascii_case("keep") { + SyntaxKind::KEEP_KW + } else if ident.eq_ignore_ascii_case("key") { + SyntaxKind::KEY_KW + } else if ident.eq_ignore_ascii_case("keys") { + SyntaxKind::KEYS_KW + } else if ident.eq_ignore_ascii_case("label") { + SyntaxKind::LABEL_KW + } else if ident.eq_ignore_ascii_case("language") { + SyntaxKind::LANGUAGE_KW + } else if ident.eq_ignore_ascii_case("large") { + SyntaxKind::LARGE_KW + } else if ident.eq_ignore_ascii_case("last") { + SyntaxKind::LAST_KW + } else if ident.eq_ignore_ascii_case("lateral") { + SyntaxKind::LATERAL_KW + } else if ident.eq_ignore_ascii_case("leading") { + SyntaxKind::LEADING_KW + } else if ident.eq_ignore_ascii_case("leakproof") { + SyntaxKind::LEAKPROOF_KW + } else if ident.eq_ignore_ascii_case("least") { + SyntaxKind::LEAST_KW + } else if ident.eq_ignore_ascii_case("left") { + SyntaxKind::LEFT_KW + } else if ident.eq_ignore_ascii_case("level") { + SyntaxKind::LEVEL_KW + } else if ident.eq_ignore_ascii_case("like") { + SyntaxKind::LIKE_KW + } else if ident.eq_ignore_ascii_case("limit") { + SyntaxKind::LIMIT_KW + } else if ident.eq_ignore_ascii_case("listen") { + SyntaxKind::LISTEN_KW + } else if ident.eq_ignore_ascii_case("load") { + SyntaxKind::LOAD_KW + } else if ident.eq_ignore_ascii_case("local") { + SyntaxKind::LOCAL_KW + } else if ident.eq_ignore_ascii_case("localtime") { + SyntaxKind::LOCALTIME_KW + } else if ident.eq_ignore_ascii_case("localtimestamp") { + SyntaxKind::LOCALTIMESTAMP_KW + } else if ident.eq_ignore_ascii_case("location") { + SyntaxKind::LOCATION_KW + } else if ident.eq_ignore_ascii_case("lock") { + SyntaxKind::LOCK_KW + } else if ident.eq_ignore_ascii_case("locked") { + SyntaxKind::LOCKED_KW + } else if ident.eq_ignore_ascii_case("logged") { + SyntaxKind::LOGGED_KW + } else if ident.eq_ignore_ascii_case("mapping") { + SyntaxKind::MAPPING_KW + } else if ident.eq_ignore_ascii_case("match") { + SyntaxKind::MATCH_KW + } else if ident.eq_ignore_ascii_case("matched") { + SyntaxKind::MATCHED_KW + } else if ident.eq_ignore_ascii_case("materialized") { + SyntaxKind::MATERIALIZED_KW + } else if ident.eq_ignore_ascii_case("maxvalue") { + SyntaxKind::MAXVALUE_KW + } else if ident.eq_ignore_ascii_case("merge") { + SyntaxKind::MERGE_KW + } else if ident.eq_ignore_ascii_case("merge_action") { + SyntaxKind::MERGE_ACTION_KW + } else if ident.eq_ignore_ascii_case("method") { + SyntaxKind::METHOD_KW + } else if ident.eq_ignore_ascii_case("minute") { + SyntaxKind::MINUTE_KW + } else if ident.eq_ignore_ascii_case("minvalue") { + SyntaxKind::MINVALUE_KW + } else if ident.eq_ignore_ascii_case("mode") { + SyntaxKind::MODE_KW + } else if ident.eq_ignore_ascii_case("month") { + SyntaxKind::MONTH_KW + } else if ident.eq_ignore_ascii_case("move") { + SyntaxKind::MOVE_KW + } else if ident.eq_ignore_ascii_case("name") { + SyntaxKind::NAME_KW + } else if ident.eq_ignore_ascii_case("names") { + SyntaxKind::NAMES_KW + } else if ident.eq_ignore_ascii_case("national") { + SyntaxKind::NATIONAL_KW + } else if ident.eq_ignore_ascii_case("natural") { + SyntaxKind::NATURAL_KW + } else if ident.eq_ignore_ascii_case("nchar") { + SyntaxKind::NCHAR_KW + } else if ident.eq_ignore_ascii_case("nested") { + SyntaxKind::NESTED_KW + } else if ident.eq_ignore_ascii_case("new") { + SyntaxKind::NEW_KW + } else if ident.eq_ignore_ascii_case("next") { + SyntaxKind::NEXT_KW + } else if ident.eq_ignore_ascii_case("nfc") { + SyntaxKind::NFC_KW + } else if ident.eq_ignore_ascii_case("nfd") { + SyntaxKind::NFD_KW + } else if ident.eq_ignore_ascii_case("nfkc") { + SyntaxKind::NFKC_KW + } else if ident.eq_ignore_ascii_case("nfkd") { + SyntaxKind::NFKD_KW + } else if ident.eq_ignore_ascii_case("no") { + SyntaxKind::NO_KW + } else if ident.eq_ignore_ascii_case("none") { + SyntaxKind::NONE_KW + } else if ident.eq_ignore_ascii_case("normalize") { + SyntaxKind::NORMALIZE_KW + } else if ident.eq_ignore_ascii_case("normalized") { + SyntaxKind::NORMALIZED_KW + } else if ident.eq_ignore_ascii_case("not") { + SyntaxKind::NOT_KW + } else if ident.eq_ignore_ascii_case("nothing") { + SyntaxKind::NOTHING_KW + } else if ident.eq_ignore_ascii_case("notify") { + SyntaxKind::NOTIFY_KW + } else if ident.eq_ignore_ascii_case("notnull") { + SyntaxKind::NOTNULL_KW + } else if ident.eq_ignore_ascii_case("nowait") { + SyntaxKind::NOWAIT_KW + } else if ident.eq_ignore_ascii_case("null") { + SyntaxKind::NULL_KW + } else if ident.eq_ignore_ascii_case("nullif") { + SyntaxKind::NULLIF_KW + } else if ident.eq_ignore_ascii_case("nulls") { + SyntaxKind::NULLS_KW + } else if ident.eq_ignore_ascii_case("numeric") { + SyntaxKind::NUMERIC_KW + } else if ident.eq_ignore_ascii_case("object") { + SyntaxKind::OBJECT_KW + } else if ident.eq_ignore_ascii_case("of") { + SyntaxKind::OF_KW + } else if ident.eq_ignore_ascii_case("off") { + SyntaxKind::OFF_KW + } else if ident.eq_ignore_ascii_case("offset") { + SyntaxKind::OFFSET_KW + } else if ident.eq_ignore_ascii_case("oids") { + SyntaxKind::OIDS_KW + } else if ident.eq_ignore_ascii_case("old") { + SyntaxKind::OLD_KW + } else if ident.eq_ignore_ascii_case("omit") { + SyntaxKind::OMIT_KW + } else if ident.eq_ignore_ascii_case("on") { + SyntaxKind::ON_KW + } else if ident.eq_ignore_ascii_case("only") { + SyntaxKind::ONLY_KW + } else if ident.eq_ignore_ascii_case("operator") { + SyntaxKind::OPERATOR_KW + } else if ident.eq_ignore_ascii_case("option") { + SyntaxKind::OPTION_KW + } else if ident.eq_ignore_ascii_case("options") { + SyntaxKind::OPTIONS_KW + } else if ident.eq_ignore_ascii_case("or") { + SyntaxKind::OR_KW + } else if ident.eq_ignore_ascii_case("order") { + SyntaxKind::ORDER_KW + } else if ident.eq_ignore_ascii_case("ordinality") { + SyntaxKind::ORDINALITY_KW + } else if ident.eq_ignore_ascii_case("others") { + SyntaxKind::OTHERS_KW + } else if ident.eq_ignore_ascii_case("out") { + SyntaxKind::OUT_KW + } else if ident.eq_ignore_ascii_case("outer") { + SyntaxKind::OUTER_KW + } else if ident.eq_ignore_ascii_case("over") { + SyntaxKind::OVER_KW + } else if ident.eq_ignore_ascii_case("overlaps") { + SyntaxKind::OVERLAPS_KW + } else if ident.eq_ignore_ascii_case("overlay") { + SyntaxKind::OVERLAY_KW + } else if ident.eq_ignore_ascii_case("overriding") { + SyntaxKind::OVERRIDING_KW + } else if ident.eq_ignore_ascii_case("owned") { + SyntaxKind::OWNED_KW + } else if ident.eq_ignore_ascii_case("owner") { + SyntaxKind::OWNER_KW + } else if ident.eq_ignore_ascii_case("parallel") { + SyntaxKind::PARALLEL_KW + } else if ident.eq_ignore_ascii_case("parameter") { + SyntaxKind::PARAMETER_KW + } else if ident.eq_ignore_ascii_case("parser") { + SyntaxKind::PARSER_KW + } else if ident.eq_ignore_ascii_case("partial") { + SyntaxKind::PARTIAL_KW + } else if ident.eq_ignore_ascii_case("partition") { + SyntaxKind::PARTITION_KW + } else if ident.eq_ignore_ascii_case("passing") { + SyntaxKind::PASSING_KW + } else if ident.eq_ignore_ascii_case("password") { + SyntaxKind::PASSWORD_KW + } else if ident.eq_ignore_ascii_case("path") { + SyntaxKind::PATH_KW + } else if ident.eq_ignore_ascii_case("period") { + SyntaxKind::PERIOD_KW + } else if ident.eq_ignore_ascii_case("placing") { + SyntaxKind::PLACING_KW + } else if ident.eq_ignore_ascii_case("plan") { + SyntaxKind::PLAN_KW + } else if ident.eq_ignore_ascii_case("plans") { + SyntaxKind::PLANS_KW + } else if ident.eq_ignore_ascii_case("policy") { + SyntaxKind::POLICY_KW + } else if ident.eq_ignore_ascii_case("position") { + SyntaxKind::POSITION_KW + } else if ident.eq_ignore_ascii_case("preceding") { + SyntaxKind::PRECEDING_KW + } else if ident.eq_ignore_ascii_case("precision") { + SyntaxKind::PRECISION_KW + } else if ident.eq_ignore_ascii_case("prepare") { + SyntaxKind::PREPARE_KW + } else if ident.eq_ignore_ascii_case("prepared") { + SyntaxKind::PREPARED_KW + } else if ident.eq_ignore_ascii_case("preserve") { + SyntaxKind::PRESERVE_KW + } else if ident.eq_ignore_ascii_case("primary") { + SyntaxKind::PRIMARY_KW + } else if ident.eq_ignore_ascii_case("prior") { + SyntaxKind::PRIOR_KW + } else if ident.eq_ignore_ascii_case("privileges") { + SyntaxKind::PRIVILEGES_KW + } else if ident.eq_ignore_ascii_case("procedural") { + SyntaxKind::PROCEDURAL_KW + } else if ident.eq_ignore_ascii_case("procedure") { + SyntaxKind::PROCEDURE_KW + } else if ident.eq_ignore_ascii_case("procedures") { + SyntaxKind::PROCEDURES_KW + } else if ident.eq_ignore_ascii_case("program") { + SyntaxKind::PROGRAM_KW + } else if ident.eq_ignore_ascii_case("publication") { + SyntaxKind::PUBLICATION_KW + } else if ident.eq_ignore_ascii_case("quote") { + SyntaxKind::QUOTE_KW + } else if ident.eq_ignore_ascii_case("quotes") { + SyntaxKind::QUOTES_KW + } else if ident.eq_ignore_ascii_case("range") { + SyntaxKind::RANGE_KW + } else if ident.eq_ignore_ascii_case("read") { + SyntaxKind::READ_KW + } else if ident.eq_ignore_ascii_case("real") { + SyntaxKind::REAL_KW + } else if ident.eq_ignore_ascii_case("reassign") { + SyntaxKind::REASSIGN_KW + } else if ident.eq_ignore_ascii_case("recursive") { + SyntaxKind::RECURSIVE_KW + } else if ident.eq_ignore_ascii_case("ref") { + SyntaxKind::REF_KW + } else if ident.eq_ignore_ascii_case("references") { + SyntaxKind::REFERENCES_KW + } else if ident.eq_ignore_ascii_case("referencing") { + SyntaxKind::REFERENCING_KW + } else if ident.eq_ignore_ascii_case("refresh") { + SyntaxKind::REFRESH_KW + } else if ident.eq_ignore_ascii_case("reindex") { + SyntaxKind::REINDEX_KW + } else if ident.eq_ignore_ascii_case("relative") { + SyntaxKind::RELATIVE_KW + } else if ident.eq_ignore_ascii_case("release") { + SyntaxKind::RELEASE_KW + } else if ident.eq_ignore_ascii_case("rename") { + SyntaxKind::RENAME_KW + } else if ident.eq_ignore_ascii_case("repeatable") { + SyntaxKind::REPEATABLE_KW + } else if ident.eq_ignore_ascii_case("replace") { + SyntaxKind::REPLACE_KW + } else if ident.eq_ignore_ascii_case("replica") { + SyntaxKind::REPLICA_KW + } else if ident.eq_ignore_ascii_case("reset") { + SyntaxKind::RESET_KW + } else if ident.eq_ignore_ascii_case("restart") { + SyntaxKind::RESTART_KW + } else if ident.eq_ignore_ascii_case("restrict") { + SyntaxKind::RESTRICT_KW + } else if ident.eq_ignore_ascii_case("restricted") { + SyntaxKind::RESTRICTED_KW + } else if ident.eq_ignore_ascii_case("return") { + SyntaxKind::RETURN_KW + } else if ident.eq_ignore_ascii_case("returning") { + SyntaxKind::RETURNING_KW + } else if ident.eq_ignore_ascii_case("returns") { + SyntaxKind::RETURNS_KW + } else if ident.eq_ignore_ascii_case("revoke") { + SyntaxKind::REVOKE_KW + } else if ident.eq_ignore_ascii_case("right") { + SyntaxKind::RIGHT_KW + } else if ident.eq_ignore_ascii_case("role") { + SyntaxKind::ROLE_KW + } else if ident.eq_ignore_ascii_case("rollback") { + SyntaxKind::ROLLBACK_KW + } else if ident.eq_ignore_ascii_case("rollup") { + SyntaxKind::ROLLUP_KW + } else if ident.eq_ignore_ascii_case("routine") { + SyntaxKind::ROUTINE_KW + } else if ident.eq_ignore_ascii_case("routines") { + SyntaxKind::ROUTINES_KW + } else if ident.eq_ignore_ascii_case("row") { + SyntaxKind::ROW_KW + } else if ident.eq_ignore_ascii_case("rows") { + SyntaxKind::ROWS_KW + } else if ident.eq_ignore_ascii_case("rule") { + SyntaxKind::RULE_KW + } else if ident.eq_ignore_ascii_case("safe") { + SyntaxKind::SAFE_KW + } else if ident.eq_ignore_ascii_case("savepoint") { + SyntaxKind::SAVEPOINT_KW + } else if ident.eq_ignore_ascii_case("scalar") { + SyntaxKind::SCALAR_KW + } else if ident.eq_ignore_ascii_case("schema") { + SyntaxKind::SCHEMA_KW + } else if ident.eq_ignore_ascii_case("schemas") { + SyntaxKind::SCHEMAS_KW + } else if ident.eq_ignore_ascii_case("scroll") { + SyntaxKind::SCROLL_KW + } else if ident.eq_ignore_ascii_case("search") { + SyntaxKind::SEARCH_KW + } else if ident.eq_ignore_ascii_case("second") { + SyntaxKind::SECOND_KW + } else if ident.eq_ignore_ascii_case("security") { + SyntaxKind::SECURITY_KW + } else if ident.eq_ignore_ascii_case("select") { + SyntaxKind::SELECT_KW + } else if ident.eq_ignore_ascii_case("sequence") { + SyntaxKind::SEQUENCE_KW + } else if ident.eq_ignore_ascii_case("sequences") { + SyntaxKind::SEQUENCES_KW + } else if ident.eq_ignore_ascii_case("serializable") { + SyntaxKind::SERIALIZABLE_KW + } else if ident.eq_ignore_ascii_case("server") { + SyntaxKind::SERVER_KW + } else if ident.eq_ignore_ascii_case("session") { + SyntaxKind::SESSION_KW + } else if ident.eq_ignore_ascii_case("session_user") { + SyntaxKind::SESSION_USER_KW + } else if ident.eq_ignore_ascii_case("set") { + SyntaxKind::SET_KW + } else if ident.eq_ignore_ascii_case("setof") { + SyntaxKind::SETOF_KW + } else if ident.eq_ignore_ascii_case("sets") { + SyntaxKind::SETS_KW + } else if ident.eq_ignore_ascii_case("share") { + SyntaxKind::SHARE_KW + } else if ident.eq_ignore_ascii_case("show") { + SyntaxKind::SHOW_KW + } else if ident.eq_ignore_ascii_case("similar") { + SyntaxKind::SIMILAR_KW + } else if ident.eq_ignore_ascii_case("simple") { + SyntaxKind::SIMPLE_KW + } else if ident.eq_ignore_ascii_case("skip") { + SyntaxKind::SKIP_KW + } else if ident.eq_ignore_ascii_case("smallint") { + SyntaxKind::SMALLINT_KW + } else if ident.eq_ignore_ascii_case("snapshot") { + SyntaxKind::SNAPSHOT_KW + } else if ident.eq_ignore_ascii_case("some") { + SyntaxKind::SOME_KW + } else if ident.eq_ignore_ascii_case("source") { + SyntaxKind::SOURCE_KW + } else if ident.eq_ignore_ascii_case("sql") { + SyntaxKind::SQL_KW + } else if ident.eq_ignore_ascii_case("stable") { + SyntaxKind::STABLE_KW + } else if ident.eq_ignore_ascii_case("standalone") { + SyntaxKind::STANDALONE_KW + } else if ident.eq_ignore_ascii_case("start") { + SyntaxKind::START_KW + } else if ident.eq_ignore_ascii_case("statement") { + SyntaxKind::STATEMENT_KW + } else if ident.eq_ignore_ascii_case("statistics") { + SyntaxKind::STATISTICS_KW + } else if ident.eq_ignore_ascii_case("stdin") { + SyntaxKind::STDIN_KW + } else if ident.eq_ignore_ascii_case("stdout") { + SyntaxKind::STDOUT_KW + } else if ident.eq_ignore_ascii_case("storage") { + SyntaxKind::STORAGE_KW + } else if ident.eq_ignore_ascii_case("stored") { + SyntaxKind::STORED_KW + } else if ident.eq_ignore_ascii_case("strict") { + SyntaxKind::STRICT_KW + } else if ident.eq_ignore_ascii_case("string") { + SyntaxKind::STRING_KW + } else if ident.eq_ignore_ascii_case("strip") { + SyntaxKind::STRIP_KW + } else if ident.eq_ignore_ascii_case("subscription") { + SyntaxKind::SUBSCRIPTION_KW + } else if ident.eq_ignore_ascii_case("substring") { + SyntaxKind::SUBSTRING_KW + } else if ident.eq_ignore_ascii_case("support") { + SyntaxKind::SUPPORT_KW + } else if ident.eq_ignore_ascii_case("symmetric") { + SyntaxKind::SYMMETRIC_KW + } else if ident.eq_ignore_ascii_case("sysid") { + SyntaxKind::SYSID_KW + } else if ident.eq_ignore_ascii_case("system") { + SyntaxKind::SYSTEM_KW + } else if ident.eq_ignore_ascii_case("system_user") { + SyntaxKind::SYSTEM_USER_KW + } else if ident.eq_ignore_ascii_case("table") { + SyntaxKind::TABLE_KW + } else if ident.eq_ignore_ascii_case("tables") { + SyntaxKind::TABLES_KW + } else if ident.eq_ignore_ascii_case("tablesample") { + SyntaxKind::TABLESAMPLE_KW + } else if ident.eq_ignore_ascii_case("tablespace") { + SyntaxKind::TABLESPACE_KW + } else if ident.eq_ignore_ascii_case("target") { + SyntaxKind::TARGET_KW + } else if ident.eq_ignore_ascii_case("temp") { + SyntaxKind::TEMP_KW + } else if ident.eq_ignore_ascii_case("template") { + SyntaxKind::TEMPLATE_KW + } else if ident.eq_ignore_ascii_case("temporary") { + SyntaxKind::TEMPORARY_KW + } else if ident.eq_ignore_ascii_case("text") { + SyntaxKind::TEXT_KW + } else if ident.eq_ignore_ascii_case("then") { + SyntaxKind::THEN_KW + } else if ident.eq_ignore_ascii_case("ties") { + SyntaxKind::TIES_KW + } else if ident.eq_ignore_ascii_case("time") { + SyntaxKind::TIME_KW + } else if ident.eq_ignore_ascii_case("timestamp") { + SyntaxKind::TIMESTAMP_KW + } else if ident.eq_ignore_ascii_case("to") { + SyntaxKind::TO_KW + } else if ident.eq_ignore_ascii_case("trailing") { + SyntaxKind::TRAILING_KW + } else if ident.eq_ignore_ascii_case("transaction") { + SyntaxKind::TRANSACTION_KW + } else if ident.eq_ignore_ascii_case("transform") { + SyntaxKind::TRANSFORM_KW + } else if ident.eq_ignore_ascii_case("treat") { + SyntaxKind::TREAT_KW + } else if ident.eq_ignore_ascii_case("trigger") { + SyntaxKind::TRIGGER_KW + } else if ident.eq_ignore_ascii_case("trim") { + SyntaxKind::TRIM_KW + } else if ident.eq_ignore_ascii_case("true") { + SyntaxKind::TRUE_KW + } else if ident.eq_ignore_ascii_case("truncate") { + SyntaxKind::TRUNCATE_KW + } else if ident.eq_ignore_ascii_case("trusted") { + SyntaxKind::TRUSTED_KW + } else if ident.eq_ignore_ascii_case("type") { + SyntaxKind::TYPE_KW + } else if ident.eq_ignore_ascii_case("types") { + SyntaxKind::TYPES_KW + } else if ident.eq_ignore_ascii_case("uescape") { + SyntaxKind::UESCAPE_KW + } else if ident.eq_ignore_ascii_case("unbounded") { + SyntaxKind::UNBOUNDED_KW + } else if ident.eq_ignore_ascii_case("uncommitted") { + SyntaxKind::UNCOMMITTED_KW + } else if ident.eq_ignore_ascii_case("unconditional") { + SyntaxKind::UNCONDITIONAL_KW + } else if ident.eq_ignore_ascii_case("unencrypted") { + SyntaxKind::UNENCRYPTED_KW + } else if ident.eq_ignore_ascii_case("union") { + SyntaxKind::UNION_KW + } else if ident.eq_ignore_ascii_case("unique") { + SyntaxKind::UNIQUE_KW + } else if ident.eq_ignore_ascii_case("unknown") { + SyntaxKind::UNKNOWN_KW + } else if ident.eq_ignore_ascii_case("unlisten") { + SyntaxKind::UNLISTEN_KW + } else if ident.eq_ignore_ascii_case("unlogged") { + SyntaxKind::UNLOGGED_KW + } else if ident.eq_ignore_ascii_case("unsafe") { + SyntaxKind::UNSAFE_KW + } else if ident.eq_ignore_ascii_case("until") { + SyntaxKind::UNTIL_KW + } else if ident.eq_ignore_ascii_case("update") { + SyntaxKind::UPDATE_KW + } else if ident.eq_ignore_ascii_case("user") { + SyntaxKind::USER_KW + } else if ident.eq_ignore_ascii_case("using") { + SyntaxKind::USING_KW + } else if ident.eq_ignore_ascii_case("vacuum") { + SyntaxKind::VACUUM_KW + } else if ident.eq_ignore_ascii_case("valid") { + SyntaxKind::VALID_KW + } else if ident.eq_ignore_ascii_case("validate") { + SyntaxKind::VALIDATE_KW + } else if ident.eq_ignore_ascii_case("validator") { + SyntaxKind::VALIDATOR_KW + } else if ident.eq_ignore_ascii_case("value") { + SyntaxKind::VALUE_KW + } else if ident.eq_ignore_ascii_case("values") { + SyntaxKind::VALUES_KW + } else if ident.eq_ignore_ascii_case("varchar") { + SyntaxKind::VARCHAR_KW + } else if ident.eq_ignore_ascii_case("variadic") { + SyntaxKind::VARIADIC_KW + } else if ident.eq_ignore_ascii_case("varying") { + SyntaxKind::VARYING_KW + } else if ident.eq_ignore_ascii_case("verbose") { + SyntaxKind::VERBOSE_KW + } else if ident.eq_ignore_ascii_case("version") { + SyntaxKind::VERSION_KW + } else if ident.eq_ignore_ascii_case("view") { + SyntaxKind::VIEW_KW + } else if ident.eq_ignore_ascii_case("views") { + SyntaxKind::VIEWS_KW + } else if ident.eq_ignore_ascii_case("volatile") { + SyntaxKind::VOLATILE_KW + } else if ident.eq_ignore_ascii_case("when") { + SyntaxKind::WHEN_KW + } else if ident.eq_ignore_ascii_case("where") { + SyntaxKind::WHERE_KW + } else if ident.eq_ignore_ascii_case("whitespace") { + SyntaxKind::WHITESPACE_KW + } else if ident.eq_ignore_ascii_case("window") { + SyntaxKind::WINDOW_KW + } else if ident.eq_ignore_ascii_case("with") { + SyntaxKind::WITH_KW + } else if ident.eq_ignore_ascii_case("within") { + SyntaxKind::WITHIN_KW + } else if ident.eq_ignore_ascii_case("without") { + SyntaxKind::WITHOUT_KW + } else if ident.eq_ignore_ascii_case("work") { + SyntaxKind::WORK_KW + } else if ident.eq_ignore_ascii_case("wrapper") { + SyntaxKind::WRAPPER_KW + } else if ident.eq_ignore_ascii_case("write") { + SyntaxKind::WRITE_KW + } else if ident.eq_ignore_ascii_case("xml") { + SyntaxKind::XML_KW + } else if ident.eq_ignore_ascii_case("xmlattributes") { + SyntaxKind::XMLATTRIBUTES_KW + } else if ident.eq_ignore_ascii_case("xmlconcat") { + SyntaxKind::XMLCONCAT_KW + } else if ident.eq_ignore_ascii_case("xmlelement") { + SyntaxKind::XMLELEMENT_KW + } else if ident.eq_ignore_ascii_case("xmlexists") { + SyntaxKind::XMLEXISTS_KW + } else if ident.eq_ignore_ascii_case("xmlforest") { + SyntaxKind::XMLFOREST_KW + } else if ident.eq_ignore_ascii_case("xmlnamespaces") { + SyntaxKind::XMLNAMESPACES_KW + } else if ident.eq_ignore_ascii_case("xmlparse") { + SyntaxKind::XMLPARSE_KW + } else if ident.eq_ignore_ascii_case("xmlpi") { + SyntaxKind::XMLPI_KW + } else if ident.eq_ignore_ascii_case("xmlroot") { + SyntaxKind::XMLROOT_KW + } else if ident.eq_ignore_ascii_case("xmlserialize") { + SyntaxKind::XMLSERIALIZE_KW + } else if ident.eq_ignore_ascii_case("xmltable") { + SyntaxKind::XMLTABLE_KW + } else if ident.eq_ignore_ascii_case("year") { + SyntaxKind::YEAR_KW + } else if ident.eq_ignore_ascii_case("yes") { + SyntaxKind::YES_KW + } else if ident.eq_ignore_ascii_case("zone") { + SyntaxKind::ZONE_KW + } else { + return None; + }; + Some(kw) + } +} diff --git a/crates/squawk_parser/src/generated/token_sets.rs b/crates/squawk_parser/src/generated/token_sets.rs new file mode 100644 index 00000000..38ceb615 --- /dev/null +++ b/crates/squawk_parser/src/generated/token_sets.rs @@ -0,0 +1,2171 @@ +use crate::syntax_kind::SyntaxKind; +use crate::token_set::TokenSet; + +pub(crate) const COLUMN_OR_TABLE_KEYWORDS: TokenSet = TokenSet::new(&[ + SyntaxKind::ABORT_KW, + SyntaxKind::ABSENT_KW, + SyntaxKind::ABSOLUTE_KW, + SyntaxKind::ACCESS_KW, + SyntaxKind::ACTION_KW, + SyntaxKind::ADD_KW, + SyntaxKind::ADMIN_KW, + SyntaxKind::AFTER_KW, + SyntaxKind::AGGREGATE_KW, + SyntaxKind::ALSO_KW, + SyntaxKind::ALTER_KW, + SyntaxKind::ALWAYS_KW, + SyntaxKind::ASENSITIVE_KW, + SyntaxKind::ASSERTION_KW, + SyntaxKind::ASSIGNMENT_KW, + SyntaxKind::ATOMIC_KW, + SyntaxKind::ATTACH_KW, + SyntaxKind::ATTRIBUTE_KW, + SyntaxKind::AT_KW, + SyntaxKind::BACKWARD_KW, + SyntaxKind::BEFORE_KW, + SyntaxKind::BEGIN_KW, + SyntaxKind::BETWEEN_KW, + SyntaxKind::BIGINT_KW, + SyntaxKind::BIT_KW, + SyntaxKind::BOOLEAN_KW, + SyntaxKind::BREADTH_KW, + SyntaxKind::BY_KW, + SyntaxKind::CACHE_KW, + SyntaxKind::CALLED_KW, + SyntaxKind::CALL_KW, + SyntaxKind::CASCADED_KW, + SyntaxKind::CASCADE_KW, + SyntaxKind::CATALOG_KW, + SyntaxKind::CHAIN_KW, + SyntaxKind::CHARACTERISTICS_KW, + SyntaxKind::CHARACTER_KW, + SyntaxKind::CHAR_KW, + SyntaxKind::CHECKPOINT_KW, + SyntaxKind::CLASS_KW, + SyntaxKind::CLOSE_KW, + SyntaxKind::CLUSTER_KW, + SyntaxKind::COALESCE_KW, + SyntaxKind::COLUMNS_KW, + SyntaxKind::COMMENTS_KW, + SyntaxKind::COMMENT_KW, + SyntaxKind::COMMITTED_KW, + SyntaxKind::COMMIT_KW, + SyntaxKind::COMPRESSION_KW, + SyntaxKind::CONDITIONAL_KW, + SyntaxKind::CONFIGURATION_KW, + SyntaxKind::CONFLICT_KW, + SyntaxKind::CONNECTION_KW, + SyntaxKind::CONSTRAINTS_KW, + SyntaxKind::CONTENT_KW, + SyntaxKind::CONTINUE_KW, + SyntaxKind::CONVERSION_KW, + SyntaxKind::COPY_KW, + SyntaxKind::COST_KW, + SyntaxKind::CSV_KW, + SyntaxKind::CUBE_KW, + SyntaxKind::CURRENT_KW, + SyntaxKind::CURSOR_KW, + SyntaxKind::CYCLE_KW, + SyntaxKind::DATABASE_KW, + SyntaxKind::DATA_KW, + SyntaxKind::DAY_KW, + SyntaxKind::DEALLOCATE_KW, + SyntaxKind::DECIMAL_KW, + SyntaxKind::DECLARE_KW, + SyntaxKind::DEC_KW, + SyntaxKind::DEFAULTS_KW, + SyntaxKind::DEFERRED_KW, + SyntaxKind::DEFINER_KW, + SyntaxKind::DELETE_KW, + SyntaxKind::DELIMITERS_KW, + SyntaxKind::DELIMITER_KW, + SyntaxKind::DEPENDS_KW, + SyntaxKind::DEPTH_KW, + SyntaxKind::DETACH_KW, + SyntaxKind::DICTIONARY_KW, + SyntaxKind::DISABLE_KW, + SyntaxKind::DISCARD_KW, + SyntaxKind::DOCUMENT_KW, + SyntaxKind::DOMAIN_KW, + SyntaxKind::DOUBLE_KW, + SyntaxKind::DROP_KW, + SyntaxKind::EACH_KW, + SyntaxKind::EMPTY_KW, + SyntaxKind::ENABLE_KW, + SyntaxKind::ENCODING_KW, + SyntaxKind::ENCRYPTED_KW, + SyntaxKind::ENUM_KW, + SyntaxKind::ERROR_KW, + SyntaxKind::ESCAPE_KW, + SyntaxKind::EVENT_KW, + SyntaxKind::EXCLUDE_KW, + SyntaxKind::EXCLUDING_KW, + SyntaxKind::EXCLUSIVE_KW, + SyntaxKind::EXECUTE_KW, + SyntaxKind::EXISTS_KW, + SyntaxKind::EXPLAIN_KW, + SyntaxKind::EXPRESSION_KW, + SyntaxKind::EXTENSION_KW, + SyntaxKind::EXTERNAL_KW, + SyntaxKind::EXTRACT_KW, + SyntaxKind::FAMILY_KW, + SyntaxKind::FILTER_KW, + SyntaxKind::FINALIZE_KW, + SyntaxKind::FIRST_KW, + SyntaxKind::FLOAT_KW, + SyntaxKind::FOLLOWING_KW, + SyntaxKind::FORCE_KW, + SyntaxKind::FORMAT_KW, + SyntaxKind::FORWARD_KW, + SyntaxKind::FUNCTIONS_KW, + SyntaxKind::FUNCTION_KW, + SyntaxKind::GENERATED_KW, + SyntaxKind::GLOBAL_KW, + SyntaxKind::GRANTED_KW, + SyntaxKind::GREATEST_KW, + SyntaxKind::GROUPING_KW, + SyntaxKind::GROUPS_KW, + SyntaxKind::HANDLER_KW, + SyntaxKind::HEADER_KW, + SyntaxKind::HOLD_KW, + SyntaxKind::HOUR_KW, + SyntaxKind::IDENTITY_KW, + SyntaxKind::IF_KW, + SyntaxKind::IMMEDIATE_KW, + SyntaxKind::IMMUTABLE_KW, + SyntaxKind::IMPLICIT_KW, + SyntaxKind::IMPORT_KW, + SyntaxKind::INCLUDE_KW, + SyntaxKind::INCLUDING_KW, + SyntaxKind::INCREMENT_KW, + SyntaxKind::INDENT_KW, + SyntaxKind::INDEXES_KW, + SyntaxKind::INDEX_KW, + SyntaxKind::INHERITS_KW, + SyntaxKind::INHERIT_KW, + SyntaxKind::INLINE_KW, + SyntaxKind::INOUT_KW, + SyntaxKind::INPUT_KW, + SyntaxKind::INSENSITIVE_KW, + SyntaxKind::INSERT_KW, + SyntaxKind::INSTEAD_KW, + SyntaxKind::INTEGER_KW, + SyntaxKind::INTERVAL_KW, + SyntaxKind::INT_KW, + SyntaxKind::INVOKER_KW, + SyntaxKind::ISOLATION_KW, + SyntaxKind::JSON_ARRAYAGG_KW, + SyntaxKind::JSON_ARRAY_KW, + SyntaxKind::JSON_EXISTS_KW, + SyntaxKind::JSON_KW, + SyntaxKind::JSON_OBJECTAGG_KW, + SyntaxKind::JSON_OBJECT_KW, + SyntaxKind::JSON_QUERY_KW, + SyntaxKind::JSON_SCALAR_KW, + SyntaxKind::JSON_SERIALIZE_KW, + SyntaxKind::JSON_TABLE_KW, + SyntaxKind::JSON_VALUE_KW, + SyntaxKind::KEEP_KW, + SyntaxKind::KEYS_KW, + SyntaxKind::KEY_KW, + SyntaxKind::LABEL_KW, + SyntaxKind::LANGUAGE_KW, + SyntaxKind::LARGE_KW, + SyntaxKind::LAST_KW, + SyntaxKind::LEAKPROOF_KW, + SyntaxKind::LEAST_KW, + SyntaxKind::LEVEL_KW, + SyntaxKind::LISTEN_KW, + SyntaxKind::LOAD_KW, + SyntaxKind::LOCAL_KW, + SyntaxKind::LOCATION_KW, + SyntaxKind::LOCKED_KW, + SyntaxKind::LOCK_KW, + SyntaxKind::LOGGED_KW, + SyntaxKind::MAPPING_KW, + SyntaxKind::MATCHED_KW, + SyntaxKind::MATCH_KW, + SyntaxKind::MATERIALIZED_KW, + SyntaxKind::MAXVALUE_KW, + SyntaxKind::MERGE_ACTION_KW, + SyntaxKind::MERGE_KW, + SyntaxKind::METHOD_KW, + SyntaxKind::MINUTE_KW, + SyntaxKind::MINVALUE_KW, + SyntaxKind::MODE_KW, + SyntaxKind::MONTH_KW, + SyntaxKind::MOVE_KW, + SyntaxKind::NAMES_KW, + SyntaxKind::NAME_KW, + SyntaxKind::NATIONAL_KW, + SyntaxKind::NCHAR_KW, + SyntaxKind::NESTED_KW, + SyntaxKind::NEW_KW, + SyntaxKind::NEXT_KW, + SyntaxKind::NFC_KW, + SyntaxKind::NFD_KW, + SyntaxKind::NFKC_KW, + SyntaxKind::NFKD_KW, + SyntaxKind::NONE_KW, + SyntaxKind::NORMALIZED_KW, + SyntaxKind::NORMALIZE_KW, + SyntaxKind::NOTHING_KW, + SyntaxKind::NOTIFY_KW, + SyntaxKind::NOWAIT_KW, + SyntaxKind::NO_KW, + SyntaxKind::NULLIF_KW, + SyntaxKind::NULLS_KW, + SyntaxKind::NUMERIC_KW, + SyntaxKind::OBJECT_KW, + SyntaxKind::OFF_KW, + SyntaxKind::OF_KW, + SyntaxKind::OIDS_KW, + SyntaxKind::OLD_KW, + SyntaxKind::OMIT_KW, + SyntaxKind::OPERATOR_KW, + SyntaxKind::OPTIONS_KW, + SyntaxKind::OPTION_KW, + SyntaxKind::ORDINALITY_KW, + SyntaxKind::OTHERS_KW, + SyntaxKind::OUT_KW, + SyntaxKind::OVERLAY_KW, + SyntaxKind::OVERRIDING_KW, + SyntaxKind::OVER_KW, + SyntaxKind::OWNED_KW, + SyntaxKind::OWNER_KW, + SyntaxKind::PARALLEL_KW, + SyntaxKind::PARAMETER_KW, + SyntaxKind::PARSER_KW, + SyntaxKind::PARTIAL_KW, + SyntaxKind::PARTITION_KW, + SyntaxKind::PASSING_KW, + SyntaxKind::PASSWORD_KW, + SyntaxKind::PATH_KW, + SyntaxKind::PERIOD_KW, + SyntaxKind::PLANS_KW, + SyntaxKind::PLAN_KW, + SyntaxKind::POLICY_KW, + SyntaxKind::POSITION_KW, + SyntaxKind::PRECEDING_KW, + SyntaxKind::PRECISION_KW, + SyntaxKind::PREPARED_KW, + SyntaxKind::PREPARE_KW, + SyntaxKind::PRESERVE_KW, + SyntaxKind::PRIOR_KW, + SyntaxKind::PRIVILEGES_KW, + SyntaxKind::PROCEDURAL_KW, + SyntaxKind::PROCEDURES_KW, + SyntaxKind::PROCEDURE_KW, + SyntaxKind::PROGRAM_KW, + SyntaxKind::PUBLICATION_KW, + SyntaxKind::QUOTES_KW, + SyntaxKind::QUOTE_KW, + SyntaxKind::RANGE_KW, + SyntaxKind::READ_KW, + SyntaxKind::REAL_KW, + SyntaxKind::REASSIGN_KW, + SyntaxKind::RECURSIVE_KW, + SyntaxKind::REFERENCING_KW, + SyntaxKind::REFRESH_KW, + SyntaxKind::REF_KW, + SyntaxKind::REINDEX_KW, + SyntaxKind::RELATIVE_KW, + SyntaxKind::RELEASE_KW, + SyntaxKind::RENAME_KW, + SyntaxKind::REPEATABLE_KW, + SyntaxKind::REPLACE_KW, + SyntaxKind::REPLICA_KW, + SyntaxKind::RESET_KW, + SyntaxKind::RESTART_KW, + SyntaxKind::RESTRICT_KW, + SyntaxKind::RETURNS_KW, + SyntaxKind::RETURN_KW, + SyntaxKind::REVOKE_KW, + SyntaxKind::ROLE_KW, + SyntaxKind::ROLLBACK_KW, + SyntaxKind::ROLLUP_KW, + SyntaxKind::ROUTINES_KW, + SyntaxKind::ROUTINE_KW, + SyntaxKind::ROWS_KW, + SyntaxKind::ROW_KW, + SyntaxKind::RULE_KW, + SyntaxKind::SAVEPOINT_KW, + SyntaxKind::SCALAR_KW, + SyntaxKind::SCHEMAS_KW, + SyntaxKind::SCHEMA_KW, + SyntaxKind::SCROLL_KW, + SyntaxKind::SEARCH_KW, + SyntaxKind::SECOND_KW, + SyntaxKind::SECURITY_KW, + SyntaxKind::SEQUENCES_KW, + SyntaxKind::SEQUENCE_KW, + SyntaxKind::SERIALIZABLE_KW, + SyntaxKind::SERVER_KW, + SyntaxKind::SESSION_KW, + SyntaxKind::SETOF_KW, + SyntaxKind::SETS_KW, + SyntaxKind::SET_KW, + SyntaxKind::SHARE_KW, + SyntaxKind::SHOW_KW, + SyntaxKind::SIMPLE_KW, + SyntaxKind::SKIP_KW, + SyntaxKind::SMALLINT_KW, + SyntaxKind::SNAPSHOT_KW, + SyntaxKind::SOURCE_KW, + SyntaxKind::SQL_KW, + SyntaxKind::STABLE_KW, + SyntaxKind::STANDALONE_KW, + SyntaxKind::START_KW, + SyntaxKind::STATEMENT_KW, + SyntaxKind::STATISTICS_KW, + SyntaxKind::STDIN_KW, + SyntaxKind::STDOUT_KW, + SyntaxKind::STORAGE_KW, + SyntaxKind::STORED_KW, + SyntaxKind::STRICT_KW, + SyntaxKind::STRING_KW, + SyntaxKind::STRIP_KW, + SyntaxKind::SUBSCRIPTION_KW, + SyntaxKind::SUBSTRING_KW, + SyntaxKind::SUPPORT_KW, + SyntaxKind::SYSID_KW, + SyntaxKind::SYSTEM_KW, + SyntaxKind::TABLESPACE_KW, + SyntaxKind::TABLES_KW, + SyntaxKind::TARGET_KW, + SyntaxKind::TEMPLATE_KW, + SyntaxKind::TEMPORARY_KW, + SyntaxKind::TEMP_KW, + SyntaxKind::TEXT_KW, + SyntaxKind::TIES_KW, + SyntaxKind::TIMESTAMP_KW, + SyntaxKind::TIME_KW, + SyntaxKind::TRANSACTION_KW, + SyntaxKind::TRANSFORM_KW, + SyntaxKind::TREAT_KW, + SyntaxKind::TRIGGER_KW, + SyntaxKind::TRIM_KW, + SyntaxKind::TRUNCATE_KW, + SyntaxKind::TRUSTED_KW, + SyntaxKind::TYPES_KW, + SyntaxKind::TYPE_KW, + SyntaxKind::UESCAPE_KW, + SyntaxKind::UNBOUNDED_KW, + SyntaxKind::UNCOMMITTED_KW, + SyntaxKind::UNCONDITIONAL_KW, + SyntaxKind::UNENCRYPTED_KW, + SyntaxKind::UNKNOWN_KW, + SyntaxKind::UNLISTEN_KW, + SyntaxKind::UNLOGGED_KW, + SyntaxKind::UNTIL_KW, + SyntaxKind::UPDATE_KW, + SyntaxKind::VACUUM_KW, + SyntaxKind::VALIDATE_KW, + SyntaxKind::VALIDATOR_KW, + SyntaxKind::VALID_KW, + SyntaxKind::VALUES_KW, + SyntaxKind::VALUE_KW, + SyntaxKind::VARCHAR_KW, + SyntaxKind::VARYING_KW, + SyntaxKind::VERSION_KW, + SyntaxKind::VIEWS_KW, + SyntaxKind::VIEW_KW, + SyntaxKind::VOLATILE_KW, + SyntaxKind::WHITESPACE_KW, + SyntaxKind::WITHIN_KW, + SyntaxKind::WITHOUT_KW, + SyntaxKind::WORK_KW, + SyntaxKind::WRAPPER_KW, + SyntaxKind::WRITE_KW, + SyntaxKind::XMLATTRIBUTES_KW, + SyntaxKind::XMLCONCAT_KW, + SyntaxKind::XMLELEMENT_KW, + SyntaxKind::XMLEXISTS_KW, + SyntaxKind::XMLFOREST_KW, + SyntaxKind::XMLNAMESPACES_KW, + SyntaxKind::XMLPARSE_KW, + SyntaxKind::XMLPI_KW, + SyntaxKind::XMLROOT_KW, + SyntaxKind::XMLSERIALIZE_KW, + SyntaxKind::XMLTABLE_KW, + SyntaxKind::XML_KW, + SyntaxKind::YEAR_KW, + SyntaxKind::YES_KW, + SyntaxKind::ZONE_KW, +]); + +pub(crate) const TYPE_KEYWORDS: TokenSet = TokenSet::new(&[ + SyntaxKind::ABORT_KW, + SyntaxKind::ABSENT_KW, + SyntaxKind::ABSOLUTE_KW, + SyntaxKind::ACCESS_KW, + SyntaxKind::ACTION_KW, + SyntaxKind::ADD_KW, + SyntaxKind::ADMIN_KW, + SyntaxKind::AFTER_KW, + SyntaxKind::AGGREGATE_KW, + SyntaxKind::ALSO_KW, + SyntaxKind::ALTER_KW, + SyntaxKind::ALWAYS_KW, + SyntaxKind::ASENSITIVE_KW, + SyntaxKind::ASSERTION_KW, + SyntaxKind::ASSIGNMENT_KW, + SyntaxKind::ATOMIC_KW, + SyntaxKind::ATTACH_KW, + SyntaxKind::ATTRIBUTE_KW, + SyntaxKind::AT_KW, + SyntaxKind::AUTHORIZATION_KW, + SyntaxKind::BACKWARD_KW, + SyntaxKind::BEFORE_KW, + SyntaxKind::BEGIN_KW, + SyntaxKind::BETWEEN_KW, + SyntaxKind::BIGINT_KW, + SyntaxKind::BINARY_KW, + SyntaxKind::BIT_KW, + SyntaxKind::BOOLEAN_KW, + SyntaxKind::BREADTH_KW, + SyntaxKind::BY_KW, + SyntaxKind::CACHE_KW, + SyntaxKind::CALLED_KW, + SyntaxKind::CALL_KW, + SyntaxKind::CASCADED_KW, + SyntaxKind::CASCADE_KW, + SyntaxKind::CATALOG_KW, + SyntaxKind::CHAIN_KW, + SyntaxKind::CHARACTERISTICS_KW, + SyntaxKind::CHARACTER_KW, + SyntaxKind::CHAR_KW, + SyntaxKind::CHECKPOINT_KW, + SyntaxKind::CLASS_KW, + SyntaxKind::CLOSE_KW, + SyntaxKind::CLUSTER_KW, + SyntaxKind::COALESCE_KW, + SyntaxKind::COLLATION_KW, + SyntaxKind::COLUMNS_KW, + SyntaxKind::COMMENTS_KW, + SyntaxKind::COMMENT_KW, + SyntaxKind::COMMITTED_KW, + SyntaxKind::COMMIT_KW, + SyntaxKind::COMPRESSION_KW, + SyntaxKind::CONCURRENTLY_KW, + SyntaxKind::CONDITIONAL_KW, + SyntaxKind::CONFIGURATION_KW, + SyntaxKind::CONFLICT_KW, + SyntaxKind::CONNECTION_KW, + SyntaxKind::CONSTRAINTS_KW, + SyntaxKind::CONTENT_KW, + SyntaxKind::CONTINUE_KW, + SyntaxKind::CONVERSION_KW, + SyntaxKind::COPY_KW, + SyntaxKind::COST_KW, + SyntaxKind::CROSS_KW, + SyntaxKind::CSV_KW, + SyntaxKind::CUBE_KW, + SyntaxKind::CURRENT_KW, + SyntaxKind::CURRENT_SCHEMA_KW, + SyntaxKind::CURSOR_KW, + SyntaxKind::CYCLE_KW, + SyntaxKind::DATABASE_KW, + SyntaxKind::DATA_KW, + SyntaxKind::DAY_KW, + SyntaxKind::DEALLOCATE_KW, + SyntaxKind::DECIMAL_KW, + SyntaxKind::DECLARE_KW, + SyntaxKind::DEC_KW, + SyntaxKind::DEFAULTS_KW, + SyntaxKind::DEFERRED_KW, + SyntaxKind::DEFINER_KW, + SyntaxKind::DELETE_KW, + SyntaxKind::DELIMITERS_KW, + SyntaxKind::DELIMITER_KW, + SyntaxKind::DEPENDS_KW, + SyntaxKind::DEPTH_KW, + SyntaxKind::DETACH_KW, + SyntaxKind::DICTIONARY_KW, + SyntaxKind::DISABLE_KW, + SyntaxKind::DISCARD_KW, + SyntaxKind::DOCUMENT_KW, + SyntaxKind::DOMAIN_KW, + SyntaxKind::DOUBLE_KW, + SyntaxKind::DROP_KW, + SyntaxKind::EACH_KW, + SyntaxKind::EMPTY_KW, + SyntaxKind::ENABLE_KW, + SyntaxKind::ENCODING_KW, + SyntaxKind::ENCRYPTED_KW, + SyntaxKind::ENUM_KW, + SyntaxKind::ERROR_KW, + SyntaxKind::ESCAPE_KW, + SyntaxKind::EVENT_KW, + SyntaxKind::EXCLUDE_KW, + SyntaxKind::EXCLUDING_KW, + SyntaxKind::EXCLUSIVE_KW, + SyntaxKind::EXECUTE_KW, + SyntaxKind::EXISTS_KW, + SyntaxKind::EXPLAIN_KW, + SyntaxKind::EXPRESSION_KW, + SyntaxKind::EXTENSION_KW, + SyntaxKind::EXTERNAL_KW, + SyntaxKind::EXTRACT_KW, + SyntaxKind::FAMILY_KW, + SyntaxKind::FILTER_KW, + SyntaxKind::FINALIZE_KW, + SyntaxKind::FIRST_KW, + SyntaxKind::FLOAT_KW, + SyntaxKind::FOLLOWING_KW, + SyntaxKind::FORCE_KW, + SyntaxKind::FORMAT_KW, + SyntaxKind::FORWARD_KW, + SyntaxKind::FREEZE_KW, + SyntaxKind::FULL_KW, + SyntaxKind::FUNCTIONS_KW, + SyntaxKind::FUNCTION_KW, + SyntaxKind::GENERATED_KW, + SyntaxKind::GLOBAL_KW, + SyntaxKind::GRANTED_KW, + SyntaxKind::GREATEST_KW, + SyntaxKind::GROUPING_KW, + SyntaxKind::GROUPS_KW, + SyntaxKind::HANDLER_KW, + SyntaxKind::HEADER_KW, + SyntaxKind::HOLD_KW, + SyntaxKind::HOUR_KW, + SyntaxKind::IDENTITY_KW, + SyntaxKind::IF_KW, + SyntaxKind::ILIKE_KW, + SyntaxKind::IMMEDIATE_KW, + SyntaxKind::IMMUTABLE_KW, + SyntaxKind::IMPLICIT_KW, + SyntaxKind::IMPORT_KW, + SyntaxKind::INCLUDE_KW, + SyntaxKind::INCLUDING_KW, + SyntaxKind::INCREMENT_KW, + SyntaxKind::INDENT_KW, + SyntaxKind::INDEXES_KW, + SyntaxKind::INDEX_KW, + SyntaxKind::INHERITS_KW, + SyntaxKind::INHERIT_KW, + SyntaxKind::INLINE_KW, + SyntaxKind::INNER_KW, + SyntaxKind::INOUT_KW, + SyntaxKind::INPUT_KW, + SyntaxKind::INSENSITIVE_KW, + SyntaxKind::INSERT_KW, + SyntaxKind::INSTEAD_KW, + SyntaxKind::INTEGER_KW, + SyntaxKind::INTERVAL_KW, + SyntaxKind::INT_KW, + SyntaxKind::INVOKER_KW, + SyntaxKind::ISNULL_KW, + SyntaxKind::ISOLATION_KW, + SyntaxKind::IS_KW, + SyntaxKind::JOIN_KW, + SyntaxKind::JSON_ARRAYAGG_KW, + SyntaxKind::JSON_ARRAY_KW, + SyntaxKind::JSON_EXISTS_KW, + SyntaxKind::JSON_KW, + SyntaxKind::JSON_OBJECTAGG_KW, + SyntaxKind::JSON_OBJECT_KW, + SyntaxKind::JSON_QUERY_KW, + SyntaxKind::JSON_SCALAR_KW, + SyntaxKind::JSON_SERIALIZE_KW, + SyntaxKind::JSON_TABLE_KW, + SyntaxKind::JSON_VALUE_KW, + SyntaxKind::KEEP_KW, + SyntaxKind::KEYS_KW, + SyntaxKind::KEY_KW, + SyntaxKind::LABEL_KW, + SyntaxKind::LANGUAGE_KW, + SyntaxKind::LARGE_KW, + SyntaxKind::LAST_KW, + SyntaxKind::LEAKPROOF_KW, + SyntaxKind::LEAST_KW, + SyntaxKind::LEFT_KW, + SyntaxKind::LEVEL_KW, + SyntaxKind::LIKE_KW, + SyntaxKind::LISTEN_KW, + SyntaxKind::LOAD_KW, + SyntaxKind::LOCAL_KW, + SyntaxKind::LOCATION_KW, + SyntaxKind::LOCKED_KW, + SyntaxKind::LOCK_KW, + SyntaxKind::LOGGED_KW, + SyntaxKind::MAPPING_KW, + SyntaxKind::MATCHED_KW, + SyntaxKind::MATCH_KW, + SyntaxKind::MATERIALIZED_KW, + SyntaxKind::MAXVALUE_KW, + SyntaxKind::MERGE_ACTION_KW, + SyntaxKind::MERGE_KW, + SyntaxKind::METHOD_KW, + SyntaxKind::MINUTE_KW, + SyntaxKind::MINVALUE_KW, + SyntaxKind::MODE_KW, + SyntaxKind::MONTH_KW, + SyntaxKind::MOVE_KW, + SyntaxKind::NAMES_KW, + SyntaxKind::NAME_KW, + SyntaxKind::NATIONAL_KW, + SyntaxKind::NATURAL_KW, + SyntaxKind::NCHAR_KW, + SyntaxKind::NESTED_KW, + SyntaxKind::NEW_KW, + SyntaxKind::NEXT_KW, + SyntaxKind::NFC_KW, + SyntaxKind::NFD_KW, + SyntaxKind::NFKC_KW, + SyntaxKind::NFKD_KW, + SyntaxKind::NONE_KW, + SyntaxKind::NORMALIZED_KW, + SyntaxKind::NORMALIZE_KW, + SyntaxKind::NOTHING_KW, + SyntaxKind::NOTIFY_KW, + SyntaxKind::NOTNULL_KW, + SyntaxKind::NOWAIT_KW, + SyntaxKind::NO_KW, + SyntaxKind::NULLIF_KW, + SyntaxKind::NULLS_KW, + SyntaxKind::NUMERIC_KW, + SyntaxKind::OBJECT_KW, + SyntaxKind::OFF_KW, + SyntaxKind::OF_KW, + SyntaxKind::OIDS_KW, + SyntaxKind::OLD_KW, + SyntaxKind::OMIT_KW, + SyntaxKind::OPERATOR_KW, + SyntaxKind::OPTIONS_KW, + SyntaxKind::OPTION_KW, + SyntaxKind::ORDINALITY_KW, + SyntaxKind::OTHERS_KW, + SyntaxKind::OUTER_KW, + SyntaxKind::OUT_KW, + SyntaxKind::OVERLAPS_KW, + SyntaxKind::OVERLAY_KW, + SyntaxKind::OVERRIDING_KW, + SyntaxKind::OVER_KW, + SyntaxKind::OWNED_KW, + SyntaxKind::OWNER_KW, + SyntaxKind::PARALLEL_KW, + SyntaxKind::PARAMETER_KW, + SyntaxKind::PARSER_KW, + SyntaxKind::PARTIAL_KW, + SyntaxKind::PARTITION_KW, + SyntaxKind::PASSING_KW, + SyntaxKind::PASSWORD_KW, + SyntaxKind::PATH_KW, + SyntaxKind::PERIOD_KW, + SyntaxKind::PLANS_KW, + SyntaxKind::PLAN_KW, + SyntaxKind::POLICY_KW, + SyntaxKind::POSITION_KW, + SyntaxKind::PRECEDING_KW, + SyntaxKind::PRECISION_KW, + SyntaxKind::PREPARED_KW, + SyntaxKind::PREPARE_KW, + SyntaxKind::PRESERVE_KW, + SyntaxKind::PRIOR_KW, + SyntaxKind::PRIVILEGES_KW, + SyntaxKind::PROCEDURAL_KW, + SyntaxKind::PROCEDURES_KW, + SyntaxKind::PROCEDURE_KW, + SyntaxKind::PROGRAM_KW, + SyntaxKind::PUBLICATION_KW, + SyntaxKind::QUOTES_KW, + SyntaxKind::QUOTE_KW, + SyntaxKind::RANGE_KW, + SyntaxKind::READ_KW, + SyntaxKind::REAL_KW, + SyntaxKind::REASSIGN_KW, + SyntaxKind::RECURSIVE_KW, + SyntaxKind::REFERENCING_KW, + SyntaxKind::REFRESH_KW, + SyntaxKind::REF_KW, + SyntaxKind::REINDEX_KW, + SyntaxKind::RELATIVE_KW, + SyntaxKind::RELEASE_KW, + SyntaxKind::RENAME_KW, + SyntaxKind::REPEATABLE_KW, + SyntaxKind::REPLACE_KW, + SyntaxKind::REPLICA_KW, + SyntaxKind::RESET_KW, + SyntaxKind::RESTART_KW, + SyntaxKind::RESTRICT_KW, + SyntaxKind::RETURNS_KW, + SyntaxKind::RETURN_KW, + SyntaxKind::REVOKE_KW, + SyntaxKind::RIGHT_KW, + SyntaxKind::ROLE_KW, + SyntaxKind::ROLLBACK_KW, + SyntaxKind::ROLLUP_KW, + SyntaxKind::ROUTINES_KW, + SyntaxKind::ROUTINE_KW, + SyntaxKind::ROWS_KW, + SyntaxKind::ROW_KW, + SyntaxKind::RULE_KW, + SyntaxKind::SAVEPOINT_KW, + SyntaxKind::SCALAR_KW, + SyntaxKind::SCHEMAS_KW, + SyntaxKind::SCHEMA_KW, + SyntaxKind::SCROLL_KW, + SyntaxKind::SEARCH_KW, + SyntaxKind::SECOND_KW, + SyntaxKind::SECURITY_KW, + SyntaxKind::SEQUENCES_KW, + SyntaxKind::SEQUENCE_KW, + SyntaxKind::SERIALIZABLE_KW, + SyntaxKind::SERVER_KW, + SyntaxKind::SESSION_KW, + SyntaxKind::SETOF_KW, + SyntaxKind::SETS_KW, + SyntaxKind::SET_KW, + SyntaxKind::SHARE_KW, + SyntaxKind::SHOW_KW, + SyntaxKind::SIMILAR_KW, + SyntaxKind::SIMPLE_KW, + SyntaxKind::SKIP_KW, + SyntaxKind::SMALLINT_KW, + SyntaxKind::SNAPSHOT_KW, + SyntaxKind::SOURCE_KW, + SyntaxKind::SQL_KW, + SyntaxKind::STABLE_KW, + SyntaxKind::STANDALONE_KW, + SyntaxKind::START_KW, + SyntaxKind::STATEMENT_KW, + SyntaxKind::STATISTICS_KW, + SyntaxKind::STDIN_KW, + SyntaxKind::STDOUT_KW, + SyntaxKind::STORAGE_KW, + SyntaxKind::STORED_KW, + SyntaxKind::STRICT_KW, + SyntaxKind::STRING_KW, + SyntaxKind::STRIP_KW, + SyntaxKind::SUBSCRIPTION_KW, + SyntaxKind::SUBSTRING_KW, + SyntaxKind::SUPPORT_KW, + SyntaxKind::SYSID_KW, + SyntaxKind::SYSTEM_KW, + SyntaxKind::TABLESAMPLE_KW, + SyntaxKind::TABLESPACE_KW, + SyntaxKind::TABLES_KW, + SyntaxKind::TARGET_KW, + SyntaxKind::TEMPLATE_KW, + SyntaxKind::TEMPORARY_KW, + SyntaxKind::TEMP_KW, + SyntaxKind::TEXT_KW, + SyntaxKind::TIES_KW, + SyntaxKind::TIMESTAMP_KW, + SyntaxKind::TIME_KW, + SyntaxKind::TRANSACTION_KW, + SyntaxKind::TRANSFORM_KW, + SyntaxKind::TREAT_KW, + SyntaxKind::TRIGGER_KW, + SyntaxKind::TRIM_KW, + SyntaxKind::TRUNCATE_KW, + SyntaxKind::TRUSTED_KW, + SyntaxKind::TYPES_KW, + SyntaxKind::TYPE_KW, + SyntaxKind::UESCAPE_KW, + SyntaxKind::UNBOUNDED_KW, + SyntaxKind::UNCOMMITTED_KW, + SyntaxKind::UNCONDITIONAL_KW, + SyntaxKind::UNENCRYPTED_KW, + SyntaxKind::UNKNOWN_KW, + SyntaxKind::UNLISTEN_KW, + SyntaxKind::UNLOGGED_KW, + SyntaxKind::UNTIL_KW, + SyntaxKind::UPDATE_KW, + SyntaxKind::VACUUM_KW, + SyntaxKind::VALIDATE_KW, + SyntaxKind::VALIDATOR_KW, + SyntaxKind::VALID_KW, + SyntaxKind::VALUES_KW, + SyntaxKind::VALUE_KW, + SyntaxKind::VARCHAR_KW, + SyntaxKind::VARYING_KW, + SyntaxKind::VERBOSE_KW, + SyntaxKind::VERSION_KW, + SyntaxKind::VIEWS_KW, + SyntaxKind::VIEW_KW, + SyntaxKind::VOLATILE_KW, + SyntaxKind::WHITESPACE_KW, + SyntaxKind::WITHIN_KW, + SyntaxKind::WITHOUT_KW, + SyntaxKind::WORK_KW, + SyntaxKind::WRAPPER_KW, + SyntaxKind::WRITE_KW, + SyntaxKind::XMLATTRIBUTES_KW, + SyntaxKind::XMLCONCAT_KW, + SyntaxKind::XMLELEMENT_KW, + SyntaxKind::XMLEXISTS_KW, + SyntaxKind::XMLFOREST_KW, + SyntaxKind::XMLNAMESPACES_KW, + SyntaxKind::XMLPARSE_KW, + SyntaxKind::XMLPI_KW, + SyntaxKind::XMLROOT_KW, + SyntaxKind::XMLSERIALIZE_KW, + SyntaxKind::XMLTABLE_KW, + SyntaxKind::XML_KW, + SyntaxKind::YEAR_KW, + SyntaxKind::YES_KW, + SyntaxKind::ZONE_KW, +]); + +pub(crate) const ALL_KEYWORDS: TokenSet = TokenSet::new(&[ + SyntaxKind::ABORT_KW, + SyntaxKind::ABSENT_KW, + SyntaxKind::ABSOLUTE_KW, + SyntaxKind::ACCESS_KW, + SyntaxKind::ACTION_KW, + SyntaxKind::ADD_KW, + SyntaxKind::ADMIN_KW, + SyntaxKind::AFTER_KW, + SyntaxKind::AGGREGATE_KW, + SyntaxKind::ALL_KW, + SyntaxKind::ALSO_KW, + SyntaxKind::ALTER_KW, + SyntaxKind::ALWAYS_KW, + SyntaxKind::ANALYSE_KW, + SyntaxKind::ANALYZE_KW, + SyntaxKind::AND_KW, + SyntaxKind::ANY_KW, + SyntaxKind::ARRAY_KW, + SyntaxKind::ASC_KW, + SyntaxKind::ASENSITIVE_KW, + SyntaxKind::ASSERTION_KW, + SyntaxKind::ASSIGNMENT_KW, + SyntaxKind::ASYMMETRIC_KW, + SyntaxKind::AS_KW, + SyntaxKind::ATOMIC_KW, + SyntaxKind::ATTACH_KW, + SyntaxKind::ATTRIBUTE_KW, + SyntaxKind::AT_KW, + SyntaxKind::AUTHORIZATION_KW, + SyntaxKind::BACKWARD_KW, + SyntaxKind::BEFORE_KW, + SyntaxKind::BEGIN_KW, + SyntaxKind::BETWEEN_KW, + SyntaxKind::BIGINT_KW, + SyntaxKind::BINARY_KW, + SyntaxKind::BIT_KW, + SyntaxKind::BOOLEAN_KW, + SyntaxKind::BOTH_KW, + SyntaxKind::BREADTH_KW, + SyntaxKind::BY_KW, + SyntaxKind::CACHE_KW, + SyntaxKind::CALLED_KW, + SyntaxKind::CALL_KW, + SyntaxKind::CASCADED_KW, + SyntaxKind::CASCADE_KW, + SyntaxKind::CASE_KW, + SyntaxKind::CAST_KW, + SyntaxKind::CATALOG_KW, + SyntaxKind::CHAIN_KW, + SyntaxKind::CHARACTERISTICS_KW, + SyntaxKind::CHARACTER_KW, + SyntaxKind::CHAR_KW, + SyntaxKind::CHECKPOINT_KW, + SyntaxKind::CHECK_KW, + SyntaxKind::CLASS_KW, + SyntaxKind::CLOSE_KW, + SyntaxKind::CLUSTER_KW, + SyntaxKind::COALESCE_KW, + SyntaxKind::COLLATE_KW, + SyntaxKind::COLLATION_KW, + SyntaxKind::COLUMNS_KW, + SyntaxKind::COLUMN_KW, + SyntaxKind::COMMENTS_KW, + SyntaxKind::COMMENT_KW, + SyntaxKind::COMMITTED_KW, + SyntaxKind::COMMIT_KW, + SyntaxKind::COMPRESSION_KW, + SyntaxKind::CONCURRENTLY_KW, + SyntaxKind::CONDITIONAL_KW, + SyntaxKind::CONFIGURATION_KW, + SyntaxKind::CONFLICT_KW, + SyntaxKind::CONNECTION_KW, + SyntaxKind::CONSTRAINTS_KW, + SyntaxKind::CONSTRAINT_KW, + SyntaxKind::CONTENT_KW, + SyntaxKind::CONTINUE_KW, + SyntaxKind::CONVERSION_KW, + SyntaxKind::COPY_KW, + SyntaxKind::COST_KW, + SyntaxKind::CREATE_KW, + SyntaxKind::CROSS_KW, + SyntaxKind::CSV_KW, + SyntaxKind::CUBE_KW, + SyntaxKind::CURRENT_CATALOG_KW, + SyntaxKind::CURRENT_DATE_KW, + SyntaxKind::CURRENT_KW, + SyntaxKind::CURRENT_ROLE_KW, + SyntaxKind::CURRENT_SCHEMA_KW, + SyntaxKind::CURRENT_TIMESTAMP_KW, + SyntaxKind::CURRENT_TIME_KW, + SyntaxKind::CURRENT_USER_KW, + SyntaxKind::CURSOR_KW, + SyntaxKind::CYCLE_KW, + SyntaxKind::DATABASE_KW, + SyntaxKind::DATA_KW, + SyntaxKind::DAY_KW, + SyntaxKind::DEALLOCATE_KW, + SyntaxKind::DECIMAL_KW, + SyntaxKind::DECLARE_KW, + SyntaxKind::DEC_KW, + SyntaxKind::DEFAULTS_KW, + SyntaxKind::DEFAULT_KW, + SyntaxKind::DEFERRABLE_KW, + SyntaxKind::DEFERRED_KW, + SyntaxKind::DEFINER_KW, + SyntaxKind::DELETE_KW, + SyntaxKind::DELIMITERS_KW, + SyntaxKind::DELIMITER_KW, + SyntaxKind::DEPENDS_KW, + SyntaxKind::DEPTH_KW, + SyntaxKind::DESC_KW, + SyntaxKind::DETACH_KW, + SyntaxKind::DICTIONARY_KW, + SyntaxKind::DISABLE_KW, + SyntaxKind::DISCARD_KW, + SyntaxKind::DISTINCT_KW, + SyntaxKind::DOCUMENT_KW, + SyntaxKind::DOMAIN_KW, + SyntaxKind::DOUBLE_KW, + SyntaxKind::DO_KW, + SyntaxKind::DROP_KW, + SyntaxKind::EACH_KW, + SyntaxKind::ELSE_KW, + SyntaxKind::EMPTY_KW, + SyntaxKind::ENABLE_KW, + SyntaxKind::ENCODING_KW, + SyntaxKind::ENCRYPTED_KW, + SyntaxKind::END_KW, + SyntaxKind::ENUM_KW, + SyntaxKind::ERROR_KW, + SyntaxKind::ESCAPE_KW, + SyntaxKind::EVENT_KW, + SyntaxKind::EXCEPT_KW, + SyntaxKind::EXCLUDE_KW, + SyntaxKind::EXCLUDING_KW, + SyntaxKind::EXCLUSIVE_KW, + SyntaxKind::EXECUTE_KW, + SyntaxKind::EXISTS_KW, + SyntaxKind::EXPLAIN_KW, + SyntaxKind::EXPRESSION_KW, + SyntaxKind::EXTENSION_KW, + SyntaxKind::EXTERNAL_KW, + SyntaxKind::EXTRACT_KW, + SyntaxKind::FALSE_KW, + SyntaxKind::FAMILY_KW, + SyntaxKind::FETCH_KW, + SyntaxKind::FILTER_KW, + SyntaxKind::FINALIZE_KW, + SyntaxKind::FIRST_KW, + SyntaxKind::FLOAT_KW, + SyntaxKind::FOLLOWING_KW, + SyntaxKind::FORCE_KW, + SyntaxKind::FOREIGN_KW, + SyntaxKind::FORMAT_KW, + SyntaxKind::FORWARD_KW, + SyntaxKind::FOR_KW, + SyntaxKind::FREEZE_KW, + SyntaxKind::FROM_KW, + SyntaxKind::FULL_KW, + SyntaxKind::FUNCTIONS_KW, + SyntaxKind::FUNCTION_KW, + SyntaxKind::GENERATED_KW, + SyntaxKind::GLOBAL_KW, + SyntaxKind::GRANTED_KW, + SyntaxKind::GRANT_KW, + SyntaxKind::GREATEST_KW, + SyntaxKind::GROUPING_KW, + SyntaxKind::GROUPS_KW, + SyntaxKind::GROUP_KW, + SyntaxKind::HANDLER_KW, + SyntaxKind::HAVING_KW, + SyntaxKind::HEADER_KW, + SyntaxKind::HOLD_KW, + SyntaxKind::HOUR_KW, + SyntaxKind::IDENTITY_KW, + SyntaxKind::IF_KW, + SyntaxKind::ILIKE_KW, + SyntaxKind::IMMEDIATE_KW, + SyntaxKind::IMMUTABLE_KW, + SyntaxKind::IMPLICIT_KW, + SyntaxKind::IMPORT_KW, + SyntaxKind::INCLUDE_KW, + SyntaxKind::INCLUDING_KW, + SyntaxKind::INCREMENT_KW, + SyntaxKind::INDENT_KW, + SyntaxKind::INDEXES_KW, + SyntaxKind::INDEX_KW, + SyntaxKind::INHERITS_KW, + SyntaxKind::INHERIT_KW, + SyntaxKind::INITIALLY_KW, + SyntaxKind::INLINE_KW, + SyntaxKind::INNER_KW, + SyntaxKind::INOUT_KW, + SyntaxKind::INPUT_KW, + SyntaxKind::INSENSITIVE_KW, + SyntaxKind::INSERT_KW, + SyntaxKind::INSTEAD_KW, + SyntaxKind::INTEGER_KW, + SyntaxKind::INTERSECT_KW, + SyntaxKind::INTERVAL_KW, + SyntaxKind::INTO_KW, + SyntaxKind::INT_KW, + SyntaxKind::INVOKER_KW, + SyntaxKind::IN_KW, + SyntaxKind::ISNULL_KW, + SyntaxKind::ISOLATION_KW, + SyntaxKind::IS_KW, + SyntaxKind::JOIN_KW, + SyntaxKind::JSON_ARRAYAGG_KW, + SyntaxKind::JSON_ARRAY_KW, + SyntaxKind::JSON_EXISTS_KW, + SyntaxKind::JSON_KW, + SyntaxKind::JSON_OBJECTAGG_KW, + SyntaxKind::JSON_OBJECT_KW, + SyntaxKind::JSON_QUERY_KW, + SyntaxKind::JSON_SCALAR_KW, + SyntaxKind::JSON_SERIALIZE_KW, + SyntaxKind::JSON_TABLE_KW, + SyntaxKind::JSON_VALUE_KW, + SyntaxKind::KEEP_KW, + SyntaxKind::KEYS_KW, + SyntaxKind::KEY_KW, + SyntaxKind::LABEL_KW, + SyntaxKind::LANGUAGE_KW, + SyntaxKind::LARGE_KW, + SyntaxKind::LAST_KW, + SyntaxKind::LATERAL_KW, + SyntaxKind::LEADING_KW, + SyntaxKind::LEAKPROOF_KW, + SyntaxKind::LEAST_KW, + SyntaxKind::LEFT_KW, + SyntaxKind::LEVEL_KW, + SyntaxKind::LIKE_KW, + SyntaxKind::LIMIT_KW, + SyntaxKind::LISTEN_KW, + SyntaxKind::LOAD_KW, + SyntaxKind::LOCALTIMESTAMP_KW, + SyntaxKind::LOCALTIME_KW, + SyntaxKind::LOCAL_KW, + SyntaxKind::LOCATION_KW, + SyntaxKind::LOCKED_KW, + SyntaxKind::LOCK_KW, + SyntaxKind::LOGGED_KW, + SyntaxKind::MAPPING_KW, + SyntaxKind::MATCHED_KW, + SyntaxKind::MATCH_KW, + SyntaxKind::MATERIALIZED_KW, + SyntaxKind::MAXVALUE_KW, + SyntaxKind::MERGE_ACTION_KW, + SyntaxKind::MERGE_KW, + SyntaxKind::METHOD_KW, + SyntaxKind::MINUTE_KW, + SyntaxKind::MINVALUE_KW, + SyntaxKind::MODE_KW, + SyntaxKind::MONTH_KW, + SyntaxKind::MOVE_KW, + SyntaxKind::NAMES_KW, + SyntaxKind::NAME_KW, + SyntaxKind::NATIONAL_KW, + SyntaxKind::NATURAL_KW, + SyntaxKind::NCHAR_KW, + SyntaxKind::NESTED_KW, + SyntaxKind::NEW_KW, + SyntaxKind::NEXT_KW, + SyntaxKind::NFC_KW, + SyntaxKind::NFD_KW, + SyntaxKind::NFKC_KW, + SyntaxKind::NFKD_KW, + SyntaxKind::NONE_KW, + SyntaxKind::NORMALIZED_KW, + SyntaxKind::NORMALIZE_KW, + SyntaxKind::NOTHING_KW, + SyntaxKind::NOTIFY_KW, + SyntaxKind::NOTNULL_KW, + SyntaxKind::NOT_KW, + SyntaxKind::NOWAIT_KW, + SyntaxKind::NO_KW, + SyntaxKind::NULLIF_KW, + SyntaxKind::NULLS_KW, + SyntaxKind::NULL_KW, + SyntaxKind::NUMERIC_KW, + SyntaxKind::OBJECT_KW, + SyntaxKind::OFFSET_KW, + SyntaxKind::OFF_KW, + SyntaxKind::OF_KW, + SyntaxKind::OIDS_KW, + SyntaxKind::OLD_KW, + SyntaxKind::OMIT_KW, + SyntaxKind::ONLY_KW, + SyntaxKind::ON_KW, + SyntaxKind::OPERATOR_KW, + SyntaxKind::OPTIONS_KW, + SyntaxKind::OPTION_KW, + SyntaxKind::ORDER_KW, + SyntaxKind::ORDINALITY_KW, + SyntaxKind::OR_KW, + SyntaxKind::OTHERS_KW, + SyntaxKind::OUTER_KW, + SyntaxKind::OUT_KW, + SyntaxKind::OVERLAPS_KW, + SyntaxKind::OVERLAY_KW, + SyntaxKind::OVERRIDING_KW, + SyntaxKind::OVER_KW, + SyntaxKind::OWNED_KW, + SyntaxKind::OWNER_KW, + SyntaxKind::PARALLEL_KW, + SyntaxKind::PARAMETER_KW, + SyntaxKind::PARSER_KW, + SyntaxKind::PARTIAL_KW, + SyntaxKind::PARTITION_KW, + SyntaxKind::PASSING_KW, + SyntaxKind::PASSWORD_KW, + SyntaxKind::PATH_KW, + SyntaxKind::PERIOD_KW, + SyntaxKind::PLACING_KW, + SyntaxKind::PLANS_KW, + SyntaxKind::PLAN_KW, + SyntaxKind::POLICY_KW, + SyntaxKind::POSITION_KW, + SyntaxKind::PRECEDING_KW, + SyntaxKind::PRECISION_KW, + SyntaxKind::PREPARED_KW, + SyntaxKind::PREPARE_KW, + SyntaxKind::PRESERVE_KW, + SyntaxKind::PRIMARY_KW, + SyntaxKind::PRIOR_KW, + SyntaxKind::PRIVILEGES_KW, + SyntaxKind::PROCEDURAL_KW, + SyntaxKind::PROCEDURES_KW, + SyntaxKind::PROCEDURE_KW, + SyntaxKind::PROGRAM_KW, + SyntaxKind::PUBLICATION_KW, + SyntaxKind::QUOTES_KW, + SyntaxKind::QUOTE_KW, + SyntaxKind::RANGE_KW, + SyntaxKind::READ_KW, + SyntaxKind::REAL_KW, + SyntaxKind::REASSIGN_KW, + SyntaxKind::RECURSIVE_KW, + SyntaxKind::REFERENCES_KW, + SyntaxKind::REFERENCING_KW, + SyntaxKind::REFRESH_KW, + SyntaxKind::REF_KW, + SyntaxKind::REINDEX_KW, + SyntaxKind::RELATIVE_KW, + SyntaxKind::RELEASE_KW, + SyntaxKind::RENAME_KW, + SyntaxKind::REPEATABLE_KW, + SyntaxKind::REPLACE_KW, + SyntaxKind::REPLICA_KW, + SyntaxKind::RESET_KW, + SyntaxKind::RESTART_KW, + SyntaxKind::RESTRICT_KW, + SyntaxKind::RETURNING_KW, + SyntaxKind::RETURNS_KW, + SyntaxKind::RETURN_KW, + SyntaxKind::REVOKE_KW, + SyntaxKind::RIGHT_KW, + SyntaxKind::ROLE_KW, + SyntaxKind::ROLLBACK_KW, + SyntaxKind::ROLLUP_KW, + SyntaxKind::ROUTINES_KW, + SyntaxKind::ROUTINE_KW, + SyntaxKind::ROWS_KW, + SyntaxKind::ROW_KW, + SyntaxKind::RULE_KW, + SyntaxKind::SAVEPOINT_KW, + SyntaxKind::SCALAR_KW, + SyntaxKind::SCHEMAS_KW, + SyntaxKind::SCHEMA_KW, + SyntaxKind::SCROLL_KW, + SyntaxKind::SEARCH_KW, + SyntaxKind::SECOND_KW, + SyntaxKind::SECURITY_KW, + SyntaxKind::SELECT_KW, + SyntaxKind::SEQUENCES_KW, + SyntaxKind::SEQUENCE_KW, + SyntaxKind::SERIALIZABLE_KW, + SyntaxKind::SERVER_KW, + SyntaxKind::SESSION_KW, + SyntaxKind::SESSION_USER_KW, + SyntaxKind::SETOF_KW, + SyntaxKind::SETS_KW, + SyntaxKind::SET_KW, + SyntaxKind::SHARE_KW, + SyntaxKind::SHOW_KW, + SyntaxKind::SIMILAR_KW, + SyntaxKind::SIMPLE_KW, + SyntaxKind::SKIP_KW, + SyntaxKind::SMALLINT_KW, + SyntaxKind::SNAPSHOT_KW, + SyntaxKind::SOME_KW, + SyntaxKind::SOURCE_KW, + SyntaxKind::SQL_KW, + SyntaxKind::STABLE_KW, + SyntaxKind::STANDALONE_KW, + SyntaxKind::START_KW, + SyntaxKind::STATEMENT_KW, + SyntaxKind::STATISTICS_KW, + SyntaxKind::STDIN_KW, + SyntaxKind::STDOUT_KW, + SyntaxKind::STORAGE_KW, + SyntaxKind::STORED_KW, + SyntaxKind::STRICT_KW, + SyntaxKind::STRING_KW, + SyntaxKind::STRIP_KW, + SyntaxKind::SUBSCRIPTION_KW, + SyntaxKind::SUBSTRING_KW, + SyntaxKind::SUPPORT_KW, + SyntaxKind::SYMMETRIC_KW, + SyntaxKind::SYSID_KW, + SyntaxKind::SYSTEM_KW, + SyntaxKind::SYSTEM_USER_KW, + SyntaxKind::TABLESAMPLE_KW, + SyntaxKind::TABLESPACE_KW, + SyntaxKind::TABLES_KW, + SyntaxKind::TABLE_KW, + SyntaxKind::TARGET_KW, + SyntaxKind::TEMPLATE_KW, + SyntaxKind::TEMPORARY_KW, + SyntaxKind::TEMP_KW, + SyntaxKind::TEXT_KW, + SyntaxKind::THEN_KW, + SyntaxKind::TIES_KW, + SyntaxKind::TIMESTAMP_KW, + SyntaxKind::TIME_KW, + SyntaxKind::TO_KW, + SyntaxKind::TRAILING_KW, + SyntaxKind::TRANSACTION_KW, + SyntaxKind::TRANSFORM_KW, + SyntaxKind::TREAT_KW, + SyntaxKind::TRIGGER_KW, + SyntaxKind::TRIM_KW, + SyntaxKind::TRUE_KW, + SyntaxKind::TRUNCATE_KW, + SyntaxKind::TRUSTED_KW, + SyntaxKind::TYPES_KW, + SyntaxKind::TYPE_KW, + SyntaxKind::UESCAPE_KW, + SyntaxKind::UNBOUNDED_KW, + SyntaxKind::UNCOMMITTED_KW, + SyntaxKind::UNCONDITIONAL_KW, + SyntaxKind::UNENCRYPTED_KW, + SyntaxKind::UNION_KW, + SyntaxKind::UNIQUE_KW, + SyntaxKind::UNKNOWN_KW, + SyntaxKind::UNLISTEN_KW, + SyntaxKind::UNLOGGED_KW, + SyntaxKind::UNTIL_KW, + SyntaxKind::UPDATE_KW, + SyntaxKind::USER_KW, + SyntaxKind::USING_KW, + SyntaxKind::VACUUM_KW, + SyntaxKind::VALIDATE_KW, + SyntaxKind::VALIDATOR_KW, + SyntaxKind::VALID_KW, + SyntaxKind::VALUES_KW, + SyntaxKind::VALUE_KW, + SyntaxKind::VARCHAR_KW, + SyntaxKind::VARIADIC_KW, + SyntaxKind::VARYING_KW, + SyntaxKind::VERBOSE_KW, + SyntaxKind::VERSION_KW, + SyntaxKind::VIEWS_KW, + SyntaxKind::VIEW_KW, + SyntaxKind::VOLATILE_KW, + SyntaxKind::WHEN_KW, + SyntaxKind::WHERE_KW, + SyntaxKind::WHITESPACE_KW, + SyntaxKind::WINDOW_KW, + SyntaxKind::WITHIN_KW, + SyntaxKind::WITHOUT_KW, + SyntaxKind::WITH_KW, + SyntaxKind::WORK_KW, + SyntaxKind::WRAPPER_KW, + SyntaxKind::WRITE_KW, + SyntaxKind::XMLATTRIBUTES_KW, + SyntaxKind::XMLCONCAT_KW, + SyntaxKind::XMLELEMENT_KW, + SyntaxKind::XMLEXISTS_KW, + SyntaxKind::XMLFOREST_KW, + SyntaxKind::XMLNAMESPACES_KW, + SyntaxKind::XMLPARSE_KW, + SyntaxKind::XMLPI_KW, + SyntaxKind::XMLROOT_KW, + SyntaxKind::XMLSERIALIZE_KW, + SyntaxKind::XMLTABLE_KW, + SyntaxKind::XML_KW, + SyntaxKind::YEAR_KW, + SyntaxKind::YES_KW, + SyntaxKind::ZONE_KW, +]); + +pub(crate) const BARE_LABEL_KEYWORDS: TokenSet = TokenSet::new(&[ + SyntaxKind::ABORT_KW, + SyntaxKind::ABSENT_KW, + SyntaxKind::ABSOLUTE_KW, + SyntaxKind::ACCESS_KW, + SyntaxKind::ACTION_KW, + SyntaxKind::ADD_KW, + SyntaxKind::ADMIN_KW, + SyntaxKind::AFTER_KW, + SyntaxKind::AGGREGATE_KW, + SyntaxKind::ALL_KW, + SyntaxKind::ALSO_KW, + SyntaxKind::ALTER_KW, + SyntaxKind::ALWAYS_KW, + SyntaxKind::ANALYSE_KW, + SyntaxKind::ANALYZE_KW, + SyntaxKind::AND_KW, + SyntaxKind::ANY_KW, + SyntaxKind::ASC_KW, + SyntaxKind::ASENSITIVE_KW, + SyntaxKind::ASSERTION_KW, + SyntaxKind::ASSIGNMENT_KW, + SyntaxKind::ASYMMETRIC_KW, + SyntaxKind::ATOMIC_KW, + SyntaxKind::ATTACH_KW, + SyntaxKind::ATTRIBUTE_KW, + SyntaxKind::AT_KW, + SyntaxKind::AUTHORIZATION_KW, + SyntaxKind::BACKWARD_KW, + SyntaxKind::BEFORE_KW, + SyntaxKind::BEGIN_KW, + SyntaxKind::BETWEEN_KW, + SyntaxKind::BIGINT_KW, + SyntaxKind::BINARY_KW, + SyntaxKind::BIT_KW, + SyntaxKind::BOOLEAN_KW, + SyntaxKind::BOTH_KW, + SyntaxKind::BREADTH_KW, + SyntaxKind::BY_KW, + SyntaxKind::CACHE_KW, + SyntaxKind::CALLED_KW, + SyntaxKind::CALL_KW, + SyntaxKind::CASCADED_KW, + SyntaxKind::CASCADE_KW, + SyntaxKind::CASE_KW, + SyntaxKind::CAST_KW, + SyntaxKind::CATALOG_KW, + SyntaxKind::CHAIN_KW, + SyntaxKind::CHARACTERISTICS_KW, + SyntaxKind::CHECKPOINT_KW, + SyntaxKind::CHECK_KW, + SyntaxKind::CLASS_KW, + SyntaxKind::CLOSE_KW, + SyntaxKind::CLUSTER_KW, + SyntaxKind::COALESCE_KW, + SyntaxKind::COLLATE_KW, + SyntaxKind::COLLATION_KW, + SyntaxKind::COLUMNS_KW, + SyntaxKind::COLUMN_KW, + SyntaxKind::COMMENTS_KW, + SyntaxKind::COMMENT_KW, + SyntaxKind::COMMITTED_KW, + SyntaxKind::COMMIT_KW, + SyntaxKind::COMPRESSION_KW, + SyntaxKind::CONCURRENTLY_KW, + SyntaxKind::CONDITIONAL_KW, + SyntaxKind::CONFIGURATION_KW, + SyntaxKind::CONFLICT_KW, + SyntaxKind::CONNECTION_KW, + SyntaxKind::CONSTRAINTS_KW, + SyntaxKind::CONSTRAINT_KW, + SyntaxKind::CONTENT_KW, + SyntaxKind::CONTINUE_KW, + SyntaxKind::CONVERSION_KW, + SyntaxKind::COPY_KW, + SyntaxKind::COST_KW, + SyntaxKind::CROSS_KW, + SyntaxKind::CSV_KW, + SyntaxKind::CUBE_KW, + SyntaxKind::CURRENT_CATALOG_KW, + SyntaxKind::CURRENT_DATE_KW, + SyntaxKind::CURRENT_KW, + SyntaxKind::CURRENT_ROLE_KW, + SyntaxKind::CURRENT_SCHEMA_KW, + SyntaxKind::CURRENT_TIMESTAMP_KW, + SyntaxKind::CURRENT_TIME_KW, + SyntaxKind::CURRENT_USER_KW, + SyntaxKind::CURSOR_KW, + SyntaxKind::CYCLE_KW, + SyntaxKind::DATABASE_KW, + SyntaxKind::DATA_KW, + SyntaxKind::DEALLOCATE_KW, + SyntaxKind::DECIMAL_KW, + SyntaxKind::DECLARE_KW, + SyntaxKind::DEC_KW, + SyntaxKind::DEFAULTS_KW, + SyntaxKind::DEFAULT_KW, + SyntaxKind::DEFERRABLE_KW, + SyntaxKind::DEFERRED_KW, + SyntaxKind::DEFINER_KW, + SyntaxKind::DELETE_KW, + SyntaxKind::DELIMITERS_KW, + SyntaxKind::DELIMITER_KW, + SyntaxKind::DEPENDS_KW, + SyntaxKind::DEPTH_KW, + SyntaxKind::DESC_KW, + SyntaxKind::DETACH_KW, + SyntaxKind::DICTIONARY_KW, + SyntaxKind::DISABLE_KW, + SyntaxKind::DISCARD_KW, + SyntaxKind::DISTINCT_KW, + SyntaxKind::DOCUMENT_KW, + SyntaxKind::DOMAIN_KW, + SyntaxKind::DOUBLE_KW, + SyntaxKind::DO_KW, + SyntaxKind::DROP_KW, + SyntaxKind::EACH_KW, + SyntaxKind::ELSE_KW, + SyntaxKind::EMPTY_KW, + SyntaxKind::ENABLE_KW, + SyntaxKind::ENCODING_KW, + SyntaxKind::ENCRYPTED_KW, + SyntaxKind::END_KW, + SyntaxKind::ENUM_KW, + SyntaxKind::ERROR_KW, + SyntaxKind::ESCAPE_KW, + SyntaxKind::EVENT_KW, + SyntaxKind::EXCLUDE_KW, + SyntaxKind::EXCLUDING_KW, + SyntaxKind::EXCLUSIVE_KW, + SyntaxKind::EXECUTE_KW, + SyntaxKind::EXISTS_KW, + SyntaxKind::EXPLAIN_KW, + SyntaxKind::EXPRESSION_KW, + SyntaxKind::EXTENSION_KW, + SyntaxKind::EXTERNAL_KW, + SyntaxKind::EXTRACT_KW, + SyntaxKind::FALSE_KW, + SyntaxKind::FAMILY_KW, + SyntaxKind::FINALIZE_KW, + SyntaxKind::FIRST_KW, + SyntaxKind::FLOAT_KW, + SyntaxKind::FOLLOWING_KW, + SyntaxKind::FORCE_KW, + SyntaxKind::FOREIGN_KW, + SyntaxKind::FORMAT_KW, + SyntaxKind::FORWARD_KW, + SyntaxKind::FREEZE_KW, + SyntaxKind::FULL_KW, + SyntaxKind::FUNCTIONS_KW, + SyntaxKind::FUNCTION_KW, + SyntaxKind::GENERATED_KW, + SyntaxKind::GLOBAL_KW, + SyntaxKind::GRANTED_KW, + SyntaxKind::GREATEST_KW, + SyntaxKind::GROUPING_KW, + SyntaxKind::GROUPS_KW, + SyntaxKind::HANDLER_KW, + SyntaxKind::HEADER_KW, + SyntaxKind::HOLD_KW, + SyntaxKind::IDENTITY_KW, + SyntaxKind::IF_KW, + SyntaxKind::ILIKE_KW, + SyntaxKind::IMMEDIATE_KW, + SyntaxKind::IMMUTABLE_KW, + SyntaxKind::IMPLICIT_KW, + SyntaxKind::IMPORT_KW, + SyntaxKind::INCLUDE_KW, + SyntaxKind::INCLUDING_KW, + SyntaxKind::INCREMENT_KW, + SyntaxKind::INDENT_KW, + SyntaxKind::INDEXES_KW, + SyntaxKind::INDEX_KW, + SyntaxKind::INHERITS_KW, + SyntaxKind::INHERIT_KW, + SyntaxKind::INITIALLY_KW, + SyntaxKind::INLINE_KW, + SyntaxKind::INNER_KW, + SyntaxKind::INOUT_KW, + SyntaxKind::INPUT_KW, + SyntaxKind::INSENSITIVE_KW, + SyntaxKind::INSERT_KW, + SyntaxKind::INSTEAD_KW, + SyntaxKind::INTEGER_KW, + SyntaxKind::INTERVAL_KW, + SyntaxKind::INT_KW, + SyntaxKind::INVOKER_KW, + SyntaxKind::IN_KW, + SyntaxKind::ISOLATION_KW, + SyntaxKind::IS_KW, + SyntaxKind::JOIN_KW, + SyntaxKind::JSON_ARRAYAGG_KW, + SyntaxKind::JSON_ARRAY_KW, + SyntaxKind::JSON_EXISTS_KW, + SyntaxKind::JSON_KW, + SyntaxKind::JSON_OBJECTAGG_KW, + SyntaxKind::JSON_OBJECT_KW, + SyntaxKind::JSON_QUERY_KW, + SyntaxKind::JSON_SCALAR_KW, + SyntaxKind::JSON_SERIALIZE_KW, + SyntaxKind::JSON_TABLE_KW, + SyntaxKind::JSON_VALUE_KW, + SyntaxKind::KEEP_KW, + SyntaxKind::KEYS_KW, + SyntaxKind::KEY_KW, + SyntaxKind::LABEL_KW, + SyntaxKind::LANGUAGE_KW, + SyntaxKind::LARGE_KW, + SyntaxKind::LAST_KW, + SyntaxKind::LATERAL_KW, + SyntaxKind::LEADING_KW, + SyntaxKind::LEAKPROOF_KW, + SyntaxKind::LEAST_KW, + SyntaxKind::LEFT_KW, + SyntaxKind::LEVEL_KW, + SyntaxKind::LIKE_KW, + SyntaxKind::LISTEN_KW, + SyntaxKind::LOAD_KW, + SyntaxKind::LOCALTIMESTAMP_KW, + SyntaxKind::LOCALTIME_KW, + SyntaxKind::LOCAL_KW, + SyntaxKind::LOCATION_KW, + SyntaxKind::LOCKED_KW, + SyntaxKind::LOCK_KW, + SyntaxKind::LOGGED_KW, + SyntaxKind::MAPPING_KW, + SyntaxKind::MATCHED_KW, + SyntaxKind::MATCH_KW, + SyntaxKind::MATERIALIZED_KW, + SyntaxKind::MAXVALUE_KW, + SyntaxKind::MERGE_ACTION_KW, + SyntaxKind::MERGE_KW, + SyntaxKind::METHOD_KW, + SyntaxKind::MINVALUE_KW, + SyntaxKind::MODE_KW, + SyntaxKind::MOVE_KW, + SyntaxKind::NAMES_KW, + SyntaxKind::NAME_KW, + SyntaxKind::NATIONAL_KW, + SyntaxKind::NATURAL_KW, + SyntaxKind::NCHAR_KW, + SyntaxKind::NESTED_KW, + SyntaxKind::NEW_KW, + SyntaxKind::NEXT_KW, + SyntaxKind::NFC_KW, + SyntaxKind::NFD_KW, + SyntaxKind::NFKC_KW, + SyntaxKind::NFKD_KW, + SyntaxKind::NONE_KW, + SyntaxKind::NORMALIZED_KW, + SyntaxKind::NORMALIZE_KW, + SyntaxKind::NOTHING_KW, + SyntaxKind::NOTIFY_KW, + SyntaxKind::NOT_KW, + SyntaxKind::NOWAIT_KW, + SyntaxKind::NO_KW, + SyntaxKind::NULLIF_KW, + SyntaxKind::NULLS_KW, + SyntaxKind::NULL_KW, + SyntaxKind::NUMERIC_KW, + SyntaxKind::OBJECT_KW, + SyntaxKind::OFF_KW, + SyntaxKind::OF_KW, + SyntaxKind::OIDS_KW, + SyntaxKind::OLD_KW, + SyntaxKind::OMIT_KW, + SyntaxKind::ONLY_KW, + SyntaxKind::OPERATOR_KW, + SyntaxKind::OPTIONS_KW, + SyntaxKind::OPTION_KW, + SyntaxKind::ORDINALITY_KW, + SyntaxKind::OR_KW, + SyntaxKind::OTHERS_KW, + SyntaxKind::OUTER_KW, + SyntaxKind::OUT_KW, + SyntaxKind::OVERLAY_KW, + SyntaxKind::OVERRIDING_KW, + SyntaxKind::OWNED_KW, + SyntaxKind::OWNER_KW, + SyntaxKind::PARALLEL_KW, + SyntaxKind::PARAMETER_KW, + SyntaxKind::PARSER_KW, + SyntaxKind::PARTIAL_KW, + SyntaxKind::PARTITION_KW, + SyntaxKind::PASSING_KW, + SyntaxKind::PASSWORD_KW, + SyntaxKind::PATH_KW, + SyntaxKind::PERIOD_KW, + SyntaxKind::PLACING_KW, + SyntaxKind::PLANS_KW, + SyntaxKind::PLAN_KW, + SyntaxKind::POLICY_KW, + SyntaxKind::POSITION_KW, + SyntaxKind::PRECEDING_KW, + SyntaxKind::PREPARED_KW, + SyntaxKind::PREPARE_KW, + SyntaxKind::PRESERVE_KW, + SyntaxKind::PRIMARY_KW, + SyntaxKind::PRIOR_KW, + SyntaxKind::PRIVILEGES_KW, + SyntaxKind::PROCEDURAL_KW, + SyntaxKind::PROCEDURES_KW, + SyntaxKind::PROCEDURE_KW, + SyntaxKind::PROGRAM_KW, + SyntaxKind::PUBLICATION_KW, + SyntaxKind::QUOTES_KW, + SyntaxKind::QUOTE_KW, + SyntaxKind::RANGE_KW, + SyntaxKind::READ_KW, + SyntaxKind::REAL_KW, + SyntaxKind::REASSIGN_KW, + SyntaxKind::RECURSIVE_KW, + SyntaxKind::REFERENCES_KW, + SyntaxKind::REFERENCING_KW, + SyntaxKind::REFRESH_KW, + SyntaxKind::REF_KW, + SyntaxKind::REINDEX_KW, + SyntaxKind::RELATIVE_KW, + SyntaxKind::RELEASE_KW, + SyntaxKind::RENAME_KW, + SyntaxKind::REPEATABLE_KW, + SyntaxKind::REPLACE_KW, + SyntaxKind::REPLICA_KW, + SyntaxKind::RESET_KW, + SyntaxKind::RESTART_KW, + SyntaxKind::RESTRICT_KW, + SyntaxKind::RETURNS_KW, + SyntaxKind::RETURN_KW, + SyntaxKind::REVOKE_KW, + SyntaxKind::RIGHT_KW, + SyntaxKind::ROLE_KW, + SyntaxKind::ROLLBACK_KW, + SyntaxKind::ROLLUP_KW, + SyntaxKind::ROUTINES_KW, + SyntaxKind::ROUTINE_KW, + SyntaxKind::ROWS_KW, + SyntaxKind::ROW_KW, + SyntaxKind::RULE_KW, + SyntaxKind::SAVEPOINT_KW, + SyntaxKind::SCALAR_KW, + SyntaxKind::SCHEMAS_KW, + SyntaxKind::SCHEMA_KW, + SyntaxKind::SCROLL_KW, + SyntaxKind::SEARCH_KW, + SyntaxKind::SECURITY_KW, + SyntaxKind::SELECT_KW, + SyntaxKind::SEQUENCES_KW, + SyntaxKind::SEQUENCE_KW, + SyntaxKind::SERIALIZABLE_KW, + SyntaxKind::SERVER_KW, + SyntaxKind::SESSION_KW, + SyntaxKind::SESSION_USER_KW, + SyntaxKind::SETOF_KW, + SyntaxKind::SETS_KW, + SyntaxKind::SET_KW, + SyntaxKind::SHARE_KW, + SyntaxKind::SHOW_KW, + SyntaxKind::SIMILAR_KW, + SyntaxKind::SIMPLE_KW, + SyntaxKind::SKIP_KW, + SyntaxKind::SMALLINT_KW, + SyntaxKind::SNAPSHOT_KW, + SyntaxKind::SOME_KW, + SyntaxKind::SOURCE_KW, + SyntaxKind::SQL_KW, + SyntaxKind::STABLE_KW, + SyntaxKind::STANDALONE_KW, + SyntaxKind::START_KW, + SyntaxKind::STATEMENT_KW, + SyntaxKind::STATISTICS_KW, + SyntaxKind::STDIN_KW, + SyntaxKind::STDOUT_KW, + SyntaxKind::STORAGE_KW, + SyntaxKind::STORED_KW, + SyntaxKind::STRICT_KW, + SyntaxKind::STRING_KW, + SyntaxKind::STRIP_KW, + SyntaxKind::SUBSCRIPTION_KW, + SyntaxKind::SUBSTRING_KW, + SyntaxKind::SUPPORT_KW, + SyntaxKind::SYMMETRIC_KW, + SyntaxKind::SYSID_KW, + SyntaxKind::SYSTEM_KW, + SyntaxKind::SYSTEM_USER_KW, + SyntaxKind::TABLESAMPLE_KW, + SyntaxKind::TABLESPACE_KW, + SyntaxKind::TABLES_KW, + SyntaxKind::TABLE_KW, + SyntaxKind::TARGET_KW, + SyntaxKind::TEMPLATE_KW, + SyntaxKind::TEMPORARY_KW, + SyntaxKind::TEMP_KW, + SyntaxKind::TEXT_KW, + SyntaxKind::THEN_KW, + SyntaxKind::TIES_KW, + SyntaxKind::TIMESTAMP_KW, + SyntaxKind::TIME_KW, + SyntaxKind::TRAILING_KW, + SyntaxKind::TRANSACTION_KW, + SyntaxKind::TRANSFORM_KW, + SyntaxKind::TREAT_KW, + SyntaxKind::TRIGGER_KW, + SyntaxKind::TRIM_KW, + SyntaxKind::TRUE_KW, + SyntaxKind::TRUNCATE_KW, + SyntaxKind::TRUSTED_KW, + SyntaxKind::TYPES_KW, + SyntaxKind::TYPE_KW, + SyntaxKind::UESCAPE_KW, + SyntaxKind::UNBOUNDED_KW, + SyntaxKind::UNCOMMITTED_KW, + SyntaxKind::UNCONDITIONAL_KW, + SyntaxKind::UNENCRYPTED_KW, + SyntaxKind::UNIQUE_KW, + SyntaxKind::UNKNOWN_KW, + SyntaxKind::UNLISTEN_KW, + SyntaxKind::UNLOGGED_KW, + SyntaxKind::UNTIL_KW, + SyntaxKind::UPDATE_KW, + SyntaxKind::USER_KW, + SyntaxKind::USING_KW, + SyntaxKind::VACUUM_KW, + SyntaxKind::VALIDATE_KW, + SyntaxKind::VALIDATOR_KW, + SyntaxKind::VALID_KW, + SyntaxKind::VALUES_KW, + SyntaxKind::VALUE_KW, + SyntaxKind::VARCHAR_KW, + SyntaxKind::VARIADIC_KW, + SyntaxKind::VERBOSE_KW, + SyntaxKind::VERSION_KW, + SyntaxKind::VIEWS_KW, + SyntaxKind::VIEW_KW, + SyntaxKind::VOLATILE_KW, + SyntaxKind::WHEN_KW, + SyntaxKind::WHITESPACE_KW, + SyntaxKind::WORK_KW, + SyntaxKind::WRAPPER_KW, + SyntaxKind::WRITE_KW, + SyntaxKind::XMLATTRIBUTES_KW, + SyntaxKind::XMLCONCAT_KW, + SyntaxKind::XMLELEMENT_KW, + SyntaxKind::XMLEXISTS_KW, + SyntaxKind::XMLFOREST_KW, + SyntaxKind::XMLNAMESPACES_KW, + SyntaxKind::XMLPARSE_KW, + SyntaxKind::XMLPI_KW, + SyntaxKind::XMLROOT_KW, + SyntaxKind::XMLSERIALIZE_KW, + SyntaxKind::XMLTABLE_KW, + SyntaxKind::XML_KW, + SyntaxKind::YES_KW, + SyntaxKind::ZONE_KW, +]); + +pub(crate) const UNRESERVED_KEYWORDS: TokenSet = TokenSet::new(&[ + SyntaxKind::ABORT_KW, + SyntaxKind::ABSENT_KW, + SyntaxKind::ABSOLUTE_KW, + SyntaxKind::ACCESS_KW, + SyntaxKind::ACTION_KW, + SyntaxKind::ADD_KW, + SyntaxKind::ADMIN_KW, + SyntaxKind::AFTER_KW, + SyntaxKind::AGGREGATE_KW, + SyntaxKind::ALSO_KW, + SyntaxKind::ALTER_KW, + SyntaxKind::ALWAYS_KW, + SyntaxKind::ASENSITIVE_KW, + SyntaxKind::ASSERTION_KW, + SyntaxKind::ASSIGNMENT_KW, + SyntaxKind::ATOMIC_KW, + SyntaxKind::ATTACH_KW, + SyntaxKind::ATTRIBUTE_KW, + SyntaxKind::AT_KW, + SyntaxKind::BACKWARD_KW, + SyntaxKind::BEFORE_KW, + SyntaxKind::BEGIN_KW, + SyntaxKind::BREADTH_KW, + SyntaxKind::BY_KW, + SyntaxKind::CACHE_KW, + SyntaxKind::CALLED_KW, + SyntaxKind::CALL_KW, + SyntaxKind::CASCADED_KW, + SyntaxKind::CASCADE_KW, + SyntaxKind::CATALOG_KW, + SyntaxKind::CHAIN_KW, + SyntaxKind::CHARACTERISTICS_KW, + SyntaxKind::CHECKPOINT_KW, + SyntaxKind::CLASS_KW, + SyntaxKind::CLOSE_KW, + SyntaxKind::CLUSTER_KW, + SyntaxKind::COLUMNS_KW, + SyntaxKind::COMMENTS_KW, + SyntaxKind::COMMENT_KW, + SyntaxKind::COMMITTED_KW, + SyntaxKind::COMMIT_KW, + SyntaxKind::COMPRESSION_KW, + SyntaxKind::CONDITIONAL_KW, + SyntaxKind::CONFIGURATION_KW, + SyntaxKind::CONFLICT_KW, + SyntaxKind::CONNECTION_KW, + SyntaxKind::CONSTRAINTS_KW, + SyntaxKind::CONTENT_KW, + SyntaxKind::CONTINUE_KW, + SyntaxKind::CONVERSION_KW, + SyntaxKind::COPY_KW, + SyntaxKind::COST_KW, + SyntaxKind::CSV_KW, + SyntaxKind::CUBE_KW, + SyntaxKind::CURRENT_KW, + SyntaxKind::CURSOR_KW, + SyntaxKind::CYCLE_KW, + SyntaxKind::DATABASE_KW, + SyntaxKind::DATA_KW, + SyntaxKind::DAY_KW, + SyntaxKind::DEALLOCATE_KW, + SyntaxKind::DECLARE_KW, + SyntaxKind::DEFAULTS_KW, + SyntaxKind::DEFERRED_KW, + SyntaxKind::DEFINER_KW, + SyntaxKind::DELETE_KW, + SyntaxKind::DELIMITERS_KW, + SyntaxKind::DELIMITER_KW, + SyntaxKind::DEPENDS_KW, + SyntaxKind::DEPTH_KW, + SyntaxKind::DETACH_KW, + SyntaxKind::DICTIONARY_KW, + SyntaxKind::DISABLE_KW, + SyntaxKind::DISCARD_KW, + SyntaxKind::DOCUMENT_KW, + SyntaxKind::DOMAIN_KW, + SyntaxKind::DOUBLE_KW, + SyntaxKind::DROP_KW, + SyntaxKind::EACH_KW, + SyntaxKind::EMPTY_KW, + SyntaxKind::ENABLE_KW, + SyntaxKind::ENCODING_KW, + SyntaxKind::ENCRYPTED_KW, + SyntaxKind::ENUM_KW, + SyntaxKind::ERROR_KW, + SyntaxKind::ESCAPE_KW, + SyntaxKind::EVENT_KW, + SyntaxKind::EXCLUDE_KW, + SyntaxKind::EXCLUDING_KW, + SyntaxKind::EXCLUSIVE_KW, + SyntaxKind::EXECUTE_KW, + SyntaxKind::EXPLAIN_KW, + SyntaxKind::EXPRESSION_KW, + SyntaxKind::EXTENSION_KW, + SyntaxKind::EXTERNAL_KW, + SyntaxKind::FAMILY_KW, + SyntaxKind::FILTER_KW, + SyntaxKind::FINALIZE_KW, + SyntaxKind::FIRST_KW, + SyntaxKind::FOLLOWING_KW, + SyntaxKind::FORCE_KW, + SyntaxKind::FORMAT_KW, + SyntaxKind::FORWARD_KW, + SyntaxKind::FUNCTIONS_KW, + SyntaxKind::FUNCTION_KW, + SyntaxKind::GENERATED_KW, + SyntaxKind::GLOBAL_KW, + SyntaxKind::GRANTED_KW, + SyntaxKind::GROUPS_KW, + SyntaxKind::HANDLER_KW, + SyntaxKind::HEADER_KW, + SyntaxKind::HOLD_KW, + SyntaxKind::HOUR_KW, + SyntaxKind::IDENTITY_KW, + SyntaxKind::IF_KW, + SyntaxKind::IMMEDIATE_KW, + SyntaxKind::IMMUTABLE_KW, + SyntaxKind::IMPLICIT_KW, + SyntaxKind::IMPORT_KW, + SyntaxKind::INCLUDE_KW, + SyntaxKind::INCLUDING_KW, + SyntaxKind::INCREMENT_KW, + SyntaxKind::INDENT_KW, + SyntaxKind::INDEXES_KW, + SyntaxKind::INDEX_KW, + SyntaxKind::INHERITS_KW, + SyntaxKind::INHERIT_KW, + SyntaxKind::INLINE_KW, + SyntaxKind::INPUT_KW, + SyntaxKind::INSENSITIVE_KW, + SyntaxKind::INSERT_KW, + SyntaxKind::INSTEAD_KW, + SyntaxKind::INVOKER_KW, + SyntaxKind::ISOLATION_KW, + SyntaxKind::KEEP_KW, + SyntaxKind::KEYS_KW, + SyntaxKind::KEY_KW, + SyntaxKind::LABEL_KW, + SyntaxKind::LANGUAGE_KW, + SyntaxKind::LARGE_KW, + SyntaxKind::LAST_KW, + SyntaxKind::LEAKPROOF_KW, + SyntaxKind::LEVEL_KW, + SyntaxKind::LISTEN_KW, + SyntaxKind::LOAD_KW, + SyntaxKind::LOCAL_KW, + SyntaxKind::LOCATION_KW, + SyntaxKind::LOCKED_KW, + SyntaxKind::LOCK_KW, + SyntaxKind::LOGGED_KW, + SyntaxKind::MAPPING_KW, + SyntaxKind::MATCHED_KW, + SyntaxKind::MATCH_KW, + SyntaxKind::MATERIALIZED_KW, + SyntaxKind::MAXVALUE_KW, + SyntaxKind::MERGE_KW, + SyntaxKind::METHOD_KW, + SyntaxKind::MINUTE_KW, + SyntaxKind::MINVALUE_KW, + SyntaxKind::MODE_KW, + SyntaxKind::MONTH_KW, + SyntaxKind::MOVE_KW, + SyntaxKind::NAMES_KW, + SyntaxKind::NAME_KW, + SyntaxKind::NESTED_KW, + SyntaxKind::NEW_KW, + SyntaxKind::NEXT_KW, + SyntaxKind::NFC_KW, + SyntaxKind::NFD_KW, + SyntaxKind::NFKC_KW, + SyntaxKind::NFKD_KW, + SyntaxKind::NORMALIZED_KW, + SyntaxKind::NOTHING_KW, + SyntaxKind::NOTIFY_KW, + SyntaxKind::NOWAIT_KW, + SyntaxKind::NO_KW, + SyntaxKind::NULLS_KW, + SyntaxKind::OBJECT_KW, + SyntaxKind::OFF_KW, + SyntaxKind::OF_KW, + SyntaxKind::OIDS_KW, + SyntaxKind::OLD_KW, + SyntaxKind::OMIT_KW, + SyntaxKind::OPERATOR_KW, + SyntaxKind::OPTIONS_KW, + SyntaxKind::OPTION_KW, + SyntaxKind::ORDINALITY_KW, + SyntaxKind::OTHERS_KW, + SyntaxKind::OVERRIDING_KW, + SyntaxKind::OVER_KW, + SyntaxKind::OWNED_KW, + SyntaxKind::OWNER_KW, + SyntaxKind::PARALLEL_KW, + SyntaxKind::PARAMETER_KW, + SyntaxKind::PARSER_KW, + SyntaxKind::PARTIAL_KW, + SyntaxKind::PARTITION_KW, + SyntaxKind::PASSING_KW, + SyntaxKind::PASSWORD_KW, + SyntaxKind::PATH_KW, + SyntaxKind::PERIOD_KW, + SyntaxKind::PLANS_KW, + SyntaxKind::PLAN_KW, + SyntaxKind::POLICY_KW, + SyntaxKind::PRECEDING_KW, + SyntaxKind::PREPARED_KW, + SyntaxKind::PREPARE_KW, + SyntaxKind::PRESERVE_KW, + SyntaxKind::PRIOR_KW, + SyntaxKind::PRIVILEGES_KW, + SyntaxKind::PROCEDURAL_KW, + SyntaxKind::PROCEDURES_KW, + SyntaxKind::PROCEDURE_KW, + SyntaxKind::PROGRAM_KW, + SyntaxKind::PUBLICATION_KW, + SyntaxKind::QUOTES_KW, + SyntaxKind::QUOTE_KW, + SyntaxKind::RANGE_KW, + SyntaxKind::READ_KW, + SyntaxKind::REASSIGN_KW, + SyntaxKind::RECURSIVE_KW, + SyntaxKind::REFERENCING_KW, + SyntaxKind::REFRESH_KW, + SyntaxKind::REF_KW, + SyntaxKind::REINDEX_KW, + SyntaxKind::RELATIVE_KW, + SyntaxKind::RELEASE_KW, + SyntaxKind::RENAME_KW, + SyntaxKind::REPEATABLE_KW, + SyntaxKind::REPLACE_KW, + SyntaxKind::REPLICA_KW, + SyntaxKind::RESET_KW, + SyntaxKind::RESTART_KW, + SyntaxKind::RESTRICT_KW, + SyntaxKind::RETURNS_KW, + SyntaxKind::RETURN_KW, + SyntaxKind::REVOKE_KW, + SyntaxKind::ROLE_KW, + SyntaxKind::ROLLBACK_KW, + SyntaxKind::ROLLUP_KW, + SyntaxKind::ROUTINES_KW, + SyntaxKind::ROUTINE_KW, + SyntaxKind::ROWS_KW, + SyntaxKind::RULE_KW, + SyntaxKind::SAVEPOINT_KW, + SyntaxKind::SCALAR_KW, + SyntaxKind::SCHEMAS_KW, + SyntaxKind::SCHEMA_KW, + SyntaxKind::SCROLL_KW, + SyntaxKind::SEARCH_KW, + SyntaxKind::SECOND_KW, + SyntaxKind::SECURITY_KW, + SyntaxKind::SEQUENCES_KW, + SyntaxKind::SEQUENCE_KW, + SyntaxKind::SERIALIZABLE_KW, + SyntaxKind::SERVER_KW, + SyntaxKind::SESSION_KW, + SyntaxKind::SETS_KW, + SyntaxKind::SET_KW, + SyntaxKind::SHARE_KW, + SyntaxKind::SHOW_KW, + SyntaxKind::SIMPLE_KW, + SyntaxKind::SKIP_KW, + SyntaxKind::SNAPSHOT_KW, + SyntaxKind::SOURCE_KW, + SyntaxKind::SQL_KW, + SyntaxKind::STABLE_KW, + SyntaxKind::STANDALONE_KW, + SyntaxKind::START_KW, + SyntaxKind::STATEMENT_KW, + SyntaxKind::STATISTICS_KW, + SyntaxKind::STDIN_KW, + SyntaxKind::STDOUT_KW, + SyntaxKind::STORAGE_KW, + SyntaxKind::STORED_KW, + SyntaxKind::STRICT_KW, + SyntaxKind::STRING_KW, + SyntaxKind::STRIP_KW, + SyntaxKind::SUBSCRIPTION_KW, + SyntaxKind::SUPPORT_KW, + SyntaxKind::SYSID_KW, + SyntaxKind::SYSTEM_KW, + SyntaxKind::TABLESPACE_KW, + SyntaxKind::TABLES_KW, + SyntaxKind::TARGET_KW, + SyntaxKind::TEMPLATE_KW, + SyntaxKind::TEMPORARY_KW, + SyntaxKind::TEMP_KW, + SyntaxKind::TEXT_KW, + SyntaxKind::TIES_KW, + SyntaxKind::TRANSACTION_KW, + SyntaxKind::TRANSFORM_KW, + SyntaxKind::TRIGGER_KW, + SyntaxKind::TRUNCATE_KW, + SyntaxKind::TRUSTED_KW, + SyntaxKind::TYPES_KW, + SyntaxKind::TYPE_KW, + SyntaxKind::UESCAPE_KW, + SyntaxKind::UNBOUNDED_KW, + SyntaxKind::UNCOMMITTED_KW, + SyntaxKind::UNCONDITIONAL_KW, + SyntaxKind::UNENCRYPTED_KW, + SyntaxKind::UNKNOWN_KW, + SyntaxKind::UNLISTEN_KW, + SyntaxKind::UNLOGGED_KW, + SyntaxKind::UNTIL_KW, + SyntaxKind::UPDATE_KW, + SyntaxKind::VACUUM_KW, + SyntaxKind::VALIDATE_KW, + SyntaxKind::VALIDATOR_KW, + SyntaxKind::VALID_KW, + SyntaxKind::VALUE_KW, + SyntaxKind::VARYING_KW, + SyntaxKind::VERSION_KW, + SyntaxKind::VIEWS_KW, + SyntaxKind::VIEW_KW, + SyntaxKind::VOLATILE_KW, + SyntaxKind::WHITESPACE_KW, + SyntaxKind::WITHIN_KW, + SyntaxKind::WITHOUT_KW, + SyntaxKind::WORK_KW, + SyntaxKind::WRAPPER_KW, + SyntaxKind::WRITE_KW, + SyntaxKind::XML_KW, + SyntaxKind::YEAR_KW, + SyntaxKind::YES_KW, + SyntaxKind::ZONE_KW, +]); + +pub(crate) const RESERVED_KEYWORDS: TokenSet = TokenSet::new(&[ + SyntaxKind::ALL_KW, + SyntaxKind::ANALYSE_KW, + SyntaxKind::ANALYZE_KW, + SyntaxKind::AND_KW, + SyntaxKind::ANY_KW, + SyntaxKind::ARRAY_KW, + SyntaxKind::ASC_KW, + SyntaxKind::ASYMMETRIC_KW, + SyntaxKind::AS_KW, + SyntaxKind::BOTH_KW, + SyntaxKind::CASE_KW, + SyntaxKind::CAST_KW, + SyntaxKind::CHECK_KW, + SyntaxKind::COLLATE_KW, + SyntaxKind::COLUMN_KW, + SyntaxKind::CONSTRAINT_KW, + SyntaxKind::CREATE_KW, + SyntaxKind::CURRENT_CATALOG_KW, + SyntaxKind::CURRENT_DATE_KW, + SyntaxKind::CURRENT_ROLE_KW, + SyntaxKind::CURRENT_TIMESTAMP_KW, + SyntaxKind::CURRENT_TIME_KW, + SyntaxKind::CURRENT_USER_KW, + SyntaxKind::DEFAULT_KW, + SyntaxKind::DEFERRABLE_KW, + SyntaxKind::DESC_KW, + SyntaxKind::DISTINCT_KW, + SyntaxKind::DO_KW, + SyntaxKind::ELSE_KW, + SyntaxKind::END_KW, + SyntaxKind::EXCEPT_KW, + SyntaxKind::FALSE_KW, + SyntaxKind::FETCH_KW, + SyntaxKind::FOREIGN_KW, + SyntaxKind::FOR_KW, + SyntaxKind::FROM_KW, + SyntaxKind::GRANT_KW, + SyntaxKind::GROUP_KW, + SyntaxKind::HAVING_KW, + SyntaxKind::INITIALLY_KW, + SyntaxKind::INTERSECT_KW, + SyntaxKind::INTO_KW, + SyntaxKind::IN_KW, + SyntaxKind::LATERAL_KW, + SyntaxKind::LEADING_KW, + SyntaxKind::LIMIT_KW, + SyntaxKind::LOCALTIMESTAMP_KW, + SyntaxKind::LOCALTIME_KW, + SyntaxKind::NOT_KW, + SyntaxKind::NULL_KW, + SyntaxKind::OFFSET_KW, + SyntaxKind::ONLY_KW, + SyntaxKind::ON_KW, + SyntaxKind::ORDER_KW, + SyntaxKind::OR_KW, + SyntaxKind::PLACING_KW, + SyntaxKind::PRIMARY_KW, + SyntaxKind::REFERENCES_KW, + SyntaxKind::RETURNING_KW, + SyntaxKind::SELECT_KW, + SyntaxKind::SESSION_USER_KW, + SyntaxKind::SOME_KW, + SyntaxKind::SYMMETRIC_KW, + SyntaxKind::SYSTEM_USER_KW, + SyntaxKind::TABLE_KW, + SyntaxKind::THEN_KW, + SyntaxKind::TO_KW, + SyntaxKind::TRAILING_KW, + SyntaxKind::TRUE_KW, + SyntaxKind::UNION_KW, + SyntaxKind::UNIQUE_KW, + SyntaxKind::USER_KW, + SyntaxKind::USING_KW, + SyntaxKind::VARIADIC_KW, + SyntaxKind::WHEN_KW, + SyntaxKind::WHERE_KW, + SyntaxKind::WINDOW_KW, + SyntaxKind::WITH_KW, +]); diff --git a/crates/squawk_parser/src/grammar.rs b/crates/squawk_parser/src/grammar.rs index fa1242dc..368cd5ed 100644 --- a/crates/squawk_parser/src/grammar.rs +++ b/crates/squawk_parser/src/grammar.rs @@ -2,11 +2,11 @@ // https://github.com/rust-lang/rust-analyzer/tree/d8887c0758bbd2d5f752d5bd405d4491e90e7ed6/crates/parser/src/grammar use crate::{ - syntax_kind::{ - SyntaxKind::{self, *}, + generated::token_sets::{ ALL_KEYWORDS, BARE_LABEL_KEYWORDS, COLUMN_OR_TABLE_KEYWORDS, RESERVED_KEYWORDS, TYPE_KEYWORDS, UNRESERVED_KEYWORDS, }, + syntax_kind::SyntaxKind::{self, *}, token_set::TokenSet, CompletedMarker, Marker, Parser, }; @@ -777,9 +777,9 @@ fn atom_expr(p: &mut Parser<'_>) -> Option { return Some(m); } let done = match (p.current(), p.nth(1)) { - (PARAM, _) => { + (POSITIONAL_PARAM, _) => { let m = p.start(); - p.bump(PARAM); + p.bump(POSITIONAL_PARAM); m.complete(p, LITERAL) } (VALUES_KW, _) => values_clause(p, None), @@ -1654,10 +1654,10 @@ fn json_key_value(p: &mut Parser<'_>, lhs: CompletedMarker) -> CompletedMarker { } fn named_arg(p: &mut Parser<'_>, lhs: CompletedMarker) -> CompletedMarker { - assert!(p.at(FAT_ARROW) || p.at(COLONEQ)); + assert!(p.at(FAT_ARROW) || p.at(COLON_EQ)); let m = lhs.precede(p); - if p.at(COLONEQ) { - p.bump(COLONEQ); + if p.at(COLON_EQ) { + p.bump(COLON_EQ); } else { p.bump(FAT_ARROW); } @@ -1668,9 +1668,9 @@ fn named_arg(p: &mut Parser<'_>, lhs: CompletedMarker) -> CompletedMarker { } fn cast_expr(p: &mut Parser<'_>, lhs: CompletedMarker) -> CompletedMarker { - assert!(p.at(COLON2)); + assert!(p.at(COLON_COLON)); let m = lhs.precede(p); - p.bump(COLON2); + p.bump(COLON_COLON); type_name(p); m.complete(p, CAST_EXPR) } @@ -2089,13 +2089,13 @@ fn current_op(p: &Parser<'_>, r: &Restrictions) -> (u8, SyntaxKind, Associativit MINUS if p.next_not_joined_op(0) => (8, MINUS, Left), // symbol // Later on we return a NAMED_ARG for this instead of BIN_EXPR // := - COLON if p.at(COLONEQ) => (5, COLONEQ, Right), // symbol + COLON if p.at(COLON_EQ) => (5, COLON_EQ, Right), // symbol // :: - COLON if p.at(COLON2) => (15, COLON2, Left), // symbol + COLON if p.at(COLON_COLON) => (15, COLON_COLON, Left), // symbol // Only used in json_object, like json_object('a' value 1) instead of json_object('a': 1) // value VALUE_KW if r.json_field_arg_allowed => (7, VALUE_KW, Right), - // Later on we return a FIELD_ARG instead of BIN_EXPR + // Later on we return a JSON_KEY_VALUE instead of BIN_EXPR // a: b COLON if r.json_field_arg_allowed => (7, COLON, Right), _ if p.at_ts(OPERATOR_FIRST) => (7, CUSTOM_OP, Right), @@ -2159,11 +2159,11 @@ fn expr_bp(p: &mut Parser<'_>, bp: u8, r: &Restrictions) -> Option { + COLON_COLON => { lhs = cast_expr(p, lhs); continue; } - FAT_ARROW | COLONEQ => { + FAT_ARROW | COLON_EQ => { lhs = named_arg(p, lhs); continue; } @@ -2740,7 +2740,7 @@ fn data_source(p: &mut Parser<'_>) { // USING data_source ON join_condition fn merge_using_clause(p: &mut Parser<'_>) { - let m1 = p.start(); + let m = p.start(); p.expect(USING_KW); data_source(p); p.expect(ON_KW); @@ -2748,7 +2748,7 @@ fn merge_using_clause(p: &mut Parser<'_>) { if expr(p).is_none() { p.error("expected an expression"); } - m1.complete(p, USING_CLAUSE); + m.complete(p, USING_CLAUSE); } // where from_item can be one of: @@ -3119,8 +3119,7 @@ fn opt_with_params(p: &mut Parser<'_>) -> Option { // [ INCLUDE ( column_name [, ... ] ) ] // [ WITH ( storage_parameter [= value] [, ... ] ) ] // [ USING INDEX TABLESPACE tablespace_name ] -#[must_use] -fn opt_index_parameters(p: &mut Parser<'_>) -> bool { +fn opt_index_parameters(p: &mut Parser<'_>) { opt_include_columns(p); opt_with_params(p); if p.at(USING_KW) { @@ -3131,7 +3130,6 @@ fn opt_index_parameters(p: &mut Parser<'_>) -> bool { name_ref(p); m.complete(p, CONSTRAINT_INDEX_TABLESPACE); } - true } // referential_action in a FOREIGN KEY/REFERENCES constraint is: @@ -3293,18 +3291,14 @@ fn opt_constraint_inner(p: &mut Parser<'_>) -> Option { p.eat(NOT_KW); p.expect(DISTINCT_KW); } - if !opt_index_parameters(p) { - p.error("expected index parameters"); - } + opt_index_parameters(p); UNIQUE_CONSTRAINT } // PRIMARY KEY index_parameters PRIMARY_KW => { p.bump(PRIMARY_KW); p.expect(KEY_KW); - if !opt_index_parameters(p) { - p.error("expected index parameters"); - } + opt_index_parameters(p); PRIMARY_KEY_CONSTRAINT } // REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] @@ -3506,9 +3500,7 @@ fn table_constraint(p: &mut Parser<'_>) -> CompletedMarker { p.eat(DISTINCT_KW); } column_list(p); - if !opt_index_parameters(p) { - p.error("expected index parameters"); - } + opt_index_parameters(p); } UNIQUE_CONSTRAINT } @@ -3523,9 +3515,7 @@ fn table_constraint(p: &mut Parser<'_>) -> CompletedMarker { // ( column_name [, ... ] ) index_parameters } else { column_list(p); - if !opt_index_parameters(p) { - p.error("expected index parameters"); - } + opt_index_parameters(p); } PRIMARY_KEY_CONSTRAINT } @@ -3553,9 +3543,7 @@ fn table_constraint(p: &mut Parser<'_>) -> CompletedMarker { } p.expect(R_PAREN); m.complete(p, CONSTRAINT_EXCLUSIONS); - if !opt_index_parameters(p) { - p.error("expected index parameters"); - } + opt_index_parameters(p); if p.at(WHERE_KW) { let m = p.start(); p.bump(WHERE_KW); @@ -3637,7 +3625,7 @@ fn opt_initally_constraint_option(p: &mut Parser<'_>) -> Option (INITIALLY_KW, DEFERRED_KW) => { p.bump(INITIALLY_KW); p.bump(DEFERRED_KW); - INITALLY_DEFERRED_CONSTRAINT_OPTION + INITIALLY_DEFERRED_CONSTRAINT_OPTION } (INITIALLY_KW, IMMEDIATE_KW) => { p.bump(INITIALLY_KW); @@ -3665,7 +3653,7 @@ fn opt_constraint_options(p: &mut Parser<'_>) { } (Some(deferrable), Some(initially)) => { if deferrable.kind() == NOT_DEFERRABLE_CONSTRAINT_OPTION - && initially.kind() == INITALLY_DEFERRED_CONSTRAINT_OPTION + && initially.kind() == INITIALLY_DEFERRED_CONSTRAINT_OPTION { p.error("constraint declared INITIALLY DEFERRED must be DEFERRABLE"); } @@ -4109,14 +4097,22 @@ const STRING_FIRST: TokenSet = TokenSet::new(&[ ]); // via https://www.postgresql.org/docs/17/sql-createoperator.html -// + - * / < > = ~ ! @ # % ^ & | ` ? pub(crate) const OPERATOR_FIRST: TokenSet = TokenSet::new(&[ PLUS, MINUS, STAR, SLASH, L_ANGLE, R_ANGLE, EQ, TILDE, BANG, AT, POUND, PERCENT, CARET, AMP, PIPE, BACKTICK, QUESTION, ]); const LHS_FIRST: TokenSet = TokenSet::new(&[ - L_PAREN, L_BRACK, CAST_KW, NOT_KW, IS_KW, PARAM, CASE_KW, ARRAY_KW, ROW_KW, DEFAULT_KW, + L_PAREN, + L_BRACK, + CAST_KW, + NOT_KW, + IS_KW, + POSITIONAL_PARAM, + CASE_KW, + ARRAY_KW, + ROW_KW, + DEFAULT_KW, ]) .union(OPERATOR_FIRST) .union(LITERAL_FIRST) @@ -4167,9 +4163,8 @@ fn opt_target_el(p: &mut Parser) -> Option { return None; } else if p.at(STAR) && !p.nth_at_ts(1, OPERATOR_FIRST) { p.bump(STAR); - true } else if expr(p).is_some() { - opt_as_col_label(p) || p.at(COMMA) + opt_as_col_label(p); } else { m.abandon(p); p.error(format!( @@ -4553,7 +4548,7 @@ fn commit_stmt(p: &mut Parser<'_>) -> CompletedMarker { p.expect(CHAIN_KW); } } - m.complete(p, COMMIT_STMT) + m.complete(p, COMMIT) } const TRANSACTION_MODE_FIRST: TokenSet = @@ -4626,7 +4621,7 @@ fn begin_stmt(p: &mut Parser<'_>) -> CompletedMarker { p.expect(TRANSACTION_KW); opt_transaction_mode_list(p); } - m.complete(p, BEGIN_STMT) + m.complete(p, BEGIN) } // Sconst @@ -9170,7 +9165,7 @@ fn drop_aggregate_stmt(p: &mut Parser<'_>) -> CompletedMarker { aggregate(p); } opt_cascade_or_restrict(p); - m.complete(p, DROP_AGGREGATE_STMT) + m.complete(p, DROP_AGGREGATE) } fn source_type_as_target_type(p: &mut Parser<'_>) { @@ -11460,16 +11455,8 @@ fn drop_schema_stmt(p: &mut Parser<'_>) -> CompletedMarker { fn opt_schema_auth(p: &mut Parser<'_>) -> bool { if p.eat(AUTHORIZATION_KW) { - if !(p.eat(CURRENT_ROLE_KW) || p.eat(CURRENT_USER_KW) || p.eat(SESSION_USER_KW)) { - if p.at_ts(UNRESERVED_KEYWORDS) || p.at(IDENT) { - p.bump_any(); - return true; - } else { - p.error("expected user_name"); - } - } else { - return true; - } + role(p); + return true; } false } @@ -12008,7 +11995,7 @@ fn create_index_stmt(p: &mut Parser<'_>) -> CompletedMarker { } // [ WHERE predicate ] opt_where_clause(p); - m.complete(p, CREATE_INDEX_STMT) + m.complete(p, CREATE_INDEX) } // ( @@ -12051,7 +12038,7 @@ fn opt_param_mode(p: &mut Parser<'_>) -> Option { IN_KW => { p.bump(IN_KW); if p.eat(OUT_KW) { - PARAM_INOUT + PARAM_IN_OUT } else { PARAM_IN } @@ -12062,7 +12049,7 @@ fn opt_param_mode(p: &mut Parser<'_>) -> Option { } INOUT_KW => { p.bump(INOUT_KW); - PARAM_INOUT + PARAM_IN_OUT } _ => { m.abandon(p); @@ -12072,6 +12059,7 @@ fn opt_param_mode(p: &mut Parser<'_>) -> Option { Some(m.complete(p, mode)) } +// [ { DEFAULT | = } default_expr ] fn opt_param_default(p: &mut Parser<'_>) -> Option { if p.at(DEFAULT_KW) || p.at(EQ) { let m = p.start(); @@ -12168,7 +12156,7 @@ fn param(p: &mut Parser<'_>) { type_name(p); } opt_param_default(p); - m.complete(p, PARAM); + m.complete(p, POSITIONAL_PARAM); } // { LANGUAGE lang_name @@ -12992,9 +12980,7 @@ fn alter_table_action(p: &mut Parser<'_>) -> Option { OWNER_KW => { p.bump(OWNER_KW); p.bump(TO_KW); - if !(p.eat(CURRENT_ROLE_KW) || p.eat(CURRENT_USER_KW) || p.eat(SESSION_USER_KW)) { - name_ref(p); - } + role(p); OWNER_TO } DETACH_KW => { diff --git a/crates/squawk_parser/src/lexed_str.rs b/crates/squawk_parser/src/lexed_str.rs index 58b14b2c..8f073177 100644 --- a/crates/squawk_parser/src/lexed_str.rs +++ b/crates/squawk_parser/src/lexed_str.rs @@ -217,7 +217,7 @@ impl<'a> Converter<'a> { } squawk_lexer::TokenKind::Eof => SyntaxKind::EOF, squawk_lexer::TokenKind::Backtick => SyntaxKind::BACKTICK, - squawk_lexer::TokenKind::Param => SyntaxKind::PARAM, + squawk_lexer::TokenKind::PositionalParam => SyntaxKind::POSITIONAL_PARAM, squawk_lexer::TokenKind::QuotedIdent { terminated } => { if !terminated { err = "Missing trailing \" to terminate the quoted identifier" diff --git a/crates/squawk_parser/src/lib.rs b/crates/squawk_parser/src/lib.rs index 07b802f6..07fd8b99 100644 --- a/crates/squawk_parser/src/lib.rs +++ b/crates/squawk_parser/src/lib.rs @@ -49,19 +49,17 @@ use event::Event; use grammar::OPERATOR_FIRST; use std::cell::Cell; use token_set::TokenSet; +mod event; +mod generated; mod grammar; -mod token_set; - +mod input; mod lexed_str; +mod output; mod shortcuts; mod syntax_kind; - -mod event; -mod input; -mod output; - #[cfg(test)] mod test; +mod token_set; pub use crate::{ lexed_str::LexedStr, @@ -213,8 +211,8 @@ impl<'t> Parser<'t> { return false; } let n_raw_tokens = match kind { - SyntaxKind::COLON2 - | SyntaxKind::COLONEQ + SyntaxKind::COLON_COLON + | SyntaxKind::COLON_EQ | SyntaxKind::NEQ | SyntaxKind::NEQB | SyntaxKind::LTEQ @@ -511,14 +509,14 @@ impl<'t> Parser<'t> { TrivaBetween::NotAllowed, ), // := - SyntaxKind::COLONEQ => self.at_composite2( + SyntaxKind::COLON_EQ => self.at_composite2( n, SyntaxKind::COLON, SyntaxKind::EQ, TrivaBetween::NotAllowed, ), // :: - SyntaxKind::COLON2 => self.at_composite2( + SyntaxKind::COLON_COLON => self.at_composite2( n, SyntaxKind::COLON, SyntaxKind::COLON, diff --git a/crates/squawk_parser/src/snapshots/squawk_parser__test__alter_foreign_table_ok.snap b/crates/squawk_parser/src/snapshots/squawk_parser__test__alter_foreign_table_ok.snap index 177500d6..8c86a1a0 100644 --- a/crates/squawk_parser/src/snapshots/squawk_parser__test__alter_foreign_table_ok.snap +++ b/crates/squawk_parser/src/snapshots/squawk_parser__test__alter_foreign_table_ok.snap @@ -1376,8 +1376,7 @@ SOURCE_FILE WHITESPACE " " TO_KW "to" WHITESPACE " " - NAME_REF - IDENT "u" + IDENT "u" SEMICOLON ";" WHITESPACE "\n\n" ALTER_FOREIGN_TABLE_STMT @@ -1479,7 +1478,6 @@ SOURCE_FILE WHITESPACE " " TO_KW "to" WHITESPACE " " - NAME_REF - IDENT "u" + IDENT "u" SEMICOLON ";" WHITESPACE "\n\n" diff --git a/crates/squawk_parser/src/snapshots/squawk_parser__test__alter_table_ok.snap b/crates/squawk_parser/src/snapshots/squawk_parser__test__alter_table_ok.snap index 5efe5a73..dfab17d4 100644 --- a/crates/squawk_parser/src/snapshots/squawk_parser__test__alter_table_ok.snap +++ b/crates/squawk_parser/src/snapshots/squawk_parser__test__alter_table_ok.snap @@ -3402,8 +3402,7 @@ SOURCE_FILE WHITESPACE " " TO_KW "to" WHITESPACE " " - NAME_REF - IDENT "new_owner" + IDENT "new_owner" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- default" diff --git a/crates/squawk_parser/src/snapshots/squawk_parser__test__create_function_ok.snap b/crates/squawk_parser/src/snapshots/squawk_parser__test__create_function_ok.snap index bf3d907f..4d1218e9 100644 --- a/crates/squawk_parser/src/snapshots/squawk_parser__test__create_function_ok.snap +++ b/crates/squawk_parser/src/snapshots/squawk_parser__test__create_function_ok.snap @@ -2247,7 +2247,7 @@ SOURCE_FILE PARAM_LIST L_PAREN "(" PARAM - PARAM_INOUT + PARAM_IN_OUT IN_KW "in" WHITESPACE " " OUT_KW "out" @@ -2290,7 +2290,7 @@ SOURCE_FILE PARAM_LIST L_PAREN "(" PARAM - PARAM_INOUT + PARAM_IN_OUT INOUT_KW "inout" WHITESPACE " " PATH_TYPE diff --git a/crates/squawk_parser/src/snapshots/squawk_parser__test__explain_ok.snap b/crates/squawk_parser/src/snapshots/squawk_parser__test__explain_ok.snap index c59b0f70..a658a787 100644 --- a/crates/squawk_parser/src/snapshots/squawk_parser__test__explain_ok.snap +++ b/crates/squawk_parser/src/snapshots/squawk_parser__test__explain_ok.snap @@ -521,7 +521,7 @@ SOURCE_FILE CAST_EXPR LITERAL PARAM "$1" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -539,7 +539,7 @@ SOURCE_FILE CAST_EXPR LITERAL PARAM "$2" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT diff --git a/crates/squawk_parser/src/snapshots/squawk_parser__test__misc_ok.snap b/crates/squawk_parser/src/snapshots/squawk_parser__test__misc_ok.snap index 5c5ef3d9..28d16b43 100644 --- a/crates/squawk_parser/src/snapshots/squawk_parser__test__misc_ok.snap +++ b/crates/squawk_parser/src/snapshots/squawk_parser__test__misc_ok.snap @@ -100,7 +100,7 @@ SOURCE_FILE CAST_EXPR LITERAL PARAM "$1" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -114,7 +114,7 @@ SOURCE_FILE CAST_EXPR LITERAL PARAM "$2" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -128,7 +128,7 @@ SOURCE_FILE CAST_EXPR LITERAL PARAM "$3" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -655,7 +655,7 @@ SOURCE_FILE CAST_EXPR LITERAL PARAM "$2" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -763,7 +763,7 @@ SOURCE_FILE L_PAREN "(" WHITESPACE " " PARAM - PARAM_INOUT + PARAM_IN_OUT INOUT_KW "INOUT" WHITESPACE " " NAME @@ -980,7 +980,7 @@ SOURCE_FILE NAME_REF IDENT "interaction_ts" R_PAREN ")" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1036,7 +1036,7 @@ SOURCE_FILE NAME_REF IDENT "interaction_ts" R_PAREN ")" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1212,7 +1212,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-12-25'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1282,7 +1282,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-12-25'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -2023,7 +2023,7 @@ SOURCE_FILE NAME_REF IDENT "plot" R_PAREN ")" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -2081,7 +2081,7 @@ SOURCE_FILE LITERAL STRING "'What is the Star Trek episode where Deanna and her mother are kidnapped?'" R_PAREN ")" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -2473,7 +2473,7 @@ SOURCE_FILE ARG_LIST L_PAREN "(" R_PAREN ")" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -2846,7 +2846,7 @@ SOURCE_FILE NAME_REF IDENT "source_table_name" WHITESPACE " " - COLONEQ ":=" + COLON_EQ ":=" WHITESPACE " " LITERAL STRING "'events'" @@ -2858,7 +2858,7 @@ SOURCE_FILE NAME_REF IDENT "batched" WHITESPACE " " - COLONEQ ":=" + COLON_EQ ":=" WHITESPACE " " LITERAL FALSE_KW "false" @@ -2870,7 +2870,7 @@ SOURCE_FILE NAME_REF IDENT "start_time" WHITESPACE " " - COLONEQ ":=" + COLON_EQ ":=" WHITESPACE " " LITERAL STRING "'2024-01-01'" @@ -3350,7 +3350,7 @@ SOURCE_FILE LITERAL STRING "'eventTypeGroups'" R_PAREN ")" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3384,7 +3384,7 @@ SOURCE_FILE LITERAL STRING "'eventTypes'" R_PAREN ")" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3513,7 +3513,7 @@ SOURCE_FILE LITERAL STRING "'bookings'" R_PAREN ")" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3557,7 +3557,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\n \"start\": \"2025-01-01T23:30:00.000Z\",\n \"eventTypeId\": 1398027,\n \"attendee\": {\n \"name\": \"Elon Musk\",\n \"email\": \"elon.musk@x.com\",\n \"timeZone\": \"America/New_York\"\n }\n }'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -5544,13 +5544,13 @@ SOURCE_FILE CAST_EXPR NAME_REF IDENT "ctid" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT NAME_REF TEXT_KW "text" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -5562,13 +5562,13 @@ SOURCE_FILE CAST_EXPR NAME_REF TIMESTAMP_KW "timestamp" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT NAME_REF TEXT_KW "text" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT diff --git a/crates/squawk_parser/src/snapshots/squawk_parser__test__select_casts_ok.snap b/crates/squawk_parser/src/snapshots/squawk_parser__test__select_casts_ok.snap index 106f622c..17f6ffa3 100644 --- a/crates/squawk_parser/src/snapshots/squawk_parser__test__select_casts_ok.snap +++ b/crates/squawk_parser/src/snapshots/squawk_parser__test__select_casts_ok.snap @@ -28,7 +28,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'1234'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -83,7 +83,7 @@ SOURCE_FILE CAST_EXPR LITERAL INT_NUMBER "44" - COLON2 "::" + COLON_COLON "::" BIT_TYPE BIT_KW "bit" L_PAREN "(" @@ -131,7 +131,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'1110'" - COLON2 "::" + COLON_COLON "::" BIT_TYPE BIT_KW "bit" L_PAREN "(" @@ -140,7 +140,7 @@ SOURCE_FILE LITERAL INT_NUMBER "4" R_PAREN ")" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -157,7 +157,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{1,2,3}'" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -177,7 +177,7 @@ SOURCE_FILE CAST_EXPR NAME_REF IDENT "foo" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -194,7 +194,7 @@ SOURCE_FILE CAST_EXPR NAME_REF IDENT "foo" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -217,7 +217,7 @@ SOURCE_FILE LITERAL STRING "'{}'" WHITESPACE " " - COLON2 "::" + COLON_COLON "::" WHITESPACE " " ARRAY_TYPE PATH_TYPE @@ -228,7 +228,7 @@ SOURCE_FILE L_BRACK "[" R_BRACK "]" WHITESPACE " " - COLON2 "::" + COLON_COLON "::" WHITESPACE " " ARRAY_TYPE PATH_TYPE @@ -239,7 +239,7 @@ SOURCE_FILE L_BRACK "[" R_BRACK "]" WHITESPACE " " - COLON2 "::" + COLON_COLON "::" WHITESPACE " " ARRAY_TYPE PATH_TYPE @@ -264,7 +264,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{}'" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -273,7 +273,7 @@ SOURCE_FILE INT_KW "int" L_BRACK "[" R_BRACK "]" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -282,7 +282,7 @@ SOURCE_FILE IDENT "int8" L_BRACK "[" R_BRACK "]" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -308,7 +308,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'1001'" - COLON2 "::" + COLON_COLON "::" BIT_TYPE BIT_KW "bit" WHITESPACE " " @@ -324,7 +324,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'1001'" - COLON2 "::" + COLON_COLON "::" BIT_TYPE BIT_KW "bit" WHITESPACE " " @@ -348,7 +348,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE CHARACTER_KW "character" SEMICOLON ";" @@ -362,7 +362,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE CHARACTER_KW "character" WHITESPACE " " @@ -378,7 +378,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE CHAR_KW "char" SEMICOLON ";" @@ -392,7 +392,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE CHAR_KW "char" WHITESPACE " " @@ -408,7 +408,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE VARCHAR_KW "varchar" SEMICOLON ";" @@ -422,7 +422,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE NATIONAL_KW "national" WHITESPACE " " @@ -438,7 +438,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE NATIONAL_KW "national" WHITESPACE " " @@ -456,7 +456,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE NATIONAL_KW "national" WHITESPACE " " @@ -472,7 +472,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE NATIONAL_KW "national" WHITESPACE " " @@ -490,7 +490,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE NCHAR_KW "nchar" SEMICOLON ";" @@ -504,7 +504,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE NCHAR_KW "nchar" WHITESPACE " " @@ -520,7 +520,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE CHAR_TYPE NCHAR_KW "nchar" @@ -541,7 +541,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIMESTAMP_KW "timestamp" @@ -560,7 +560,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIMESTAMP_KW "timestamp" @@ -586,7 +586,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIMESTAMP_KW "timestamp" @@ -612,7 +612,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIMESTAMP_KW "timestamp" @@ -627,7 +627,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIMESTAMP_KW "timestamp" @@ -649,7 +649,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIMESTAMP_KW "timestamp" @@ -671,7 +671,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIME_KW "time" @@ -690,7 +690,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIME_KW "time" @@ -716,7 +716,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIME_KW "time" @@ -742,7 +742,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIME_KW "time" @@ -757,7 +757,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIME_KW "time" @@ -779,7 +779,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2024-01-01 12:34:56.123456'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIME_KW "time" @@ -990,7 +990,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" SEMICOLON ";" @@ -1004,7 +1004,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1020,7 +1020,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1036,7 +1036,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1052,7 +1052,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1068,7 +1068,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1084,7 +1084,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1100,7 +1100,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1120,7 +1120,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1140,7 +1140,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1160,7 +1160,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1180,7 +1180,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1200,7 +1200,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1224,7 +1224,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1244,7 +1244,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1264,7 +1264,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1288,7 +1288,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1308,7 +1308,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" WHITESPACE " " @@ -1332,7 +1332,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'10 days'" - COLON2 "::" + COLON_COLON "::" INTERVAL_TYPE INTERVAL_KW "interval" L_PAREN "(" @@ -1354,7 +1354,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1374,7 +1374,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'\"foo\"'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1388,7 +1388,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'\"foo\"'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1407,7 +1407,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH @@ -1429,7 +1429,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH @@ -1462,7 +1462,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE VARCHAR_KW "varchar" SEMICOLON ";" @@ -1476,7 +1476,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'abc'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE VARCHAR_KW "varchar" L_PAREN "(" @@ -1496,7 +1496,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE CHAR_TYPE VARCHAR_KW "varchar" @@ -1519,7 +1519,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE CHAR_TYPE VARCHAR_KW "varchar" @@ -1538,7 +1538,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -1564,7 +1564,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH @@ -1592,7 +1592,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -1624,7 +1624,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -1662,7 +1662,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1679,7 +1679,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1696,7 +1696,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1713,7 +1713,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1730,7 +1730,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1747,7 +1747,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1770,7 +1770,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" DOUBLE_TYPE DOUBLE_KW "double" WHITESPACE " " @@ -1786,7 +1786,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1803,7 +1803,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1836,7 +1836,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1853,7 +1853,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1886,7 +1886,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1903,7 +1903,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1931,7 +1931,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -1948,7 +1948,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -2293,7 +2293,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "''" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE CHAR_KW "char" L_PAREN "(" @@ -2320,7 +2320,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'a '" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE CHAR_KW "CHAR" L_PAREN "(" @@ -2340,7 +2340,7 @@ SOURCE_FILE CAST_EXPR LITERAL ESC_STRING "E'a\\n'" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE CHAR_KW "CHAR" L_PAREN "(" @@ -2508,7 +2508,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{1}'" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -2548,7 +2548,7 @@ SOURCE_FILE ARRAY_KW "array" L_BRACK "[" R_BRACK "]" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -2570,7 +2570,7 @@ SOURCE_FILE CAST_EXPR LITERAL INT_NUMBER "44" - COLON2 "::" + COLON_COLON "::" BIT_TYPE BIT_KW "bit" L_PAREN "(" @@ -2592,7 +2592,7 @@ SOURCE_FILE CAST_EXPR LITERAL INT_NUMBER "44" - COLON2 "::" + COLON_COLON "::" BIT_TYPE BIT_KW "bit" L_PAREN "(" @@ -2644,7 +2644,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'1110'" - COLON2 "::" + COLON_COLON "::" BIT_TYPE BIT_KW "bit" L_PAREN "(" @@ -2653,7 +2653,7 @@ SOURCE_FILE LITERAL INT_NUMBER "4" R_PAREN ")" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -2672,7 +2672,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'1'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH @@ -2694,7 +2694,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{1}'" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH diff --git a/crates/squawk_parser/src/snapshots/squawk_parser__test__select_compound_union_select_ok.snap b/crates/squawk_parser/src/snapshots/squawk_parser__test__select_compound_union_select_ok.snap index 9b2878c7..14efdf21 100644 --- a/crates/squawk_parser/src/snapshots/squawk_parser__test__select_compound_union_select_ok.snap +++ b/crates/squawk_parser/src/snapshots/squawk_parser__test__select_compound_union_select_ok.snap @@ -45,7 +45,7 @@ SOURCE_FILE CAST_EXPR NAME_REF LANGUAGE_KW "language" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE CHAR_KW "char" L_PAREN "(" @@ -173,7 +173,7 @@ SOURCE_FILE CAST_EXPR NAME_REF LANGUAGE_KW "language" - COLON2 "::" + COLON_COLON "::" CHAR_TYPE CHAR_KW "char" L_PAREN "(" diff --git a/crates/squawk_parser/src/snapshots/squawk_parser__test__select_funcs_ok.snap b/crates/squawk_parser/src/snapshots/squawk_parser__test__select_funcs_ok.snap index 3e4b7a44..642b1369 100644 --- a/crates/squawk_parser/src/snapshots/squawk_parser__test__select_funcs_ok.snap +++ b/crates/squawk_parser/src/snapshots/squawk_parser__test__select_funcs_ok.snap @@ -2675,7 +2675,7 @@ SOURCE_FILE NAME_REF IDENT "a" WHITESPACE " " - COLONEQ ":=" + COLON_EQ ":=" WHITESPACE " " LITERAL TRUE_KW "true" @@ -3573,7 +3573,7 @@ SOURCE_FILE ARRAY_KW "array" L_BRACK "[" R_BRACK "]" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH diff --git a/crates/squawk_parser/src/snapshots/squawk_parser__test__select_funcs_pg17_ok.snap b/crates/squawk_parser/src/snapshots/squawk_parser__test__select_funcs_pg17_ok.snap index 60387b40..c4909e4a 100644 --- a/crates/squawk_parser/src/snapshots/squawk_parser__test__select_funcs_pg17_ok.snap +++ b/crates/squawk_parser/src/snapshots/squawk_parser__test__select_funcs_pg17_ok.snap @@ -394,7 +394,7 @@ SOURCE_FILE 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}}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT diff --git a/crates/squawk_parser/src/snapshots/squawk_parser__test__select_operators_ok.snap b/crates/squawk_parser/src/snapshots/squawk_parser__test__select_operators_ok.snap index d2e41336..6396ea0f 100644 --- a/crates/squawk_parser/src/snapshots/squawk_parser__test__select_operators_ok.snap +++ b/crates/squawk_parser/src/snapshots/squawk_parser__test__select_operators_ok.snap @@ -1141,7 +1141,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'cat'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -2910,7 +2910,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[{\"a\":\"foo\"},{\"b\":\"bar\"},{\"c\":\"baz\"}]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -2935,7 +2935,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\": {\"b\":\"foo\"}}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -2962,7 +2962,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[1,2,3]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -2988,7 +2988,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\":1,\"b\":2}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3016,7 +3016,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\": {\"b\": [\"foo\",\"bar\"]}}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3043,7 +3043,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\": {\"b\": [\"foo\",\"bar\"]}}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3071,7 +3071,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'\"foo\"'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3085,7 +3085,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'\"foo\"'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3103,7 +3103,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"b\":2}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3117,7 +3117,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\":1, \"b\":2}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3137,7 +3137,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\":1, \"b\":2}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3161,7 +3161,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[\"a\", \"b\", \"c\"]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3187,7 +3187,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\":1, \"b\":2, \"c\":3}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3222,7 +3222,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[\"a\", \"b\", \"c\"]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3257,7 +3257,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[\"a\", \"b\"]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3271,7 +3271,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[\"a\", \"d\"]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3289,7 +3289,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\": \"b\"}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3303,7 +3303,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"c\": \"d\"}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3321,7 +3321,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[1, 2]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3335,7 +3335,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'3'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3353,7 +3353,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\": \"b\"}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3367,7 +3367,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'42'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3385,7 +3385,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[1, 2]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3404,7 +3404,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[3, 4]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3425,7 +3425,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\": \"b\", \"c\": \"d\"}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3448,7 +3448,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[\"a\", \"b\", \"c\", \"b\"]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3471,7 +3471,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\": \"b\", \"c\": \"d\"}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3483,7 +3483,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{a,c}'" - COLON2 "::" + COLON_COLON "::" ARRAY_TYPE PATH_TYPE PATH @@ -3504,7 +3504,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[\"a\", \"b\"]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3529,7 +3529,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[\"a\", {\"b\":1}]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3556,7 +3556,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"items\": [1, 2, 3]}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3583,7 +3583,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\":[1,2,3,4,5]}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3642,7 +3642,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[1, \"2\", null]'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3667,7 +3667,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\": 1}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -3694,7 +3694,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'{\"a\": {\"b\": {\"c\": 1}}}'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -4084,7 +4084,7 @@ SOURCE_FILE DOT "." NAME_REF IDENT "b" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -4338,7 +4338,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'[2011-01-01,2011-03-01)'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT @@ -4352,7 +4352,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'2011-01-10'" - COLON2 "::" + COLON_COLON "::" TIME_TYPE NAME_REF TIMESTAMP_KW "timestamp" diff --git a/crates/squawk_parser/src/snapshots/squawk_parser__test__values_ok.snap b/crates/squawk_parser/src/snapshots/squawk_parser__test__values_ok.snap index 7b1128d7..e476429d 100644 --- a/crates/squawk_parser/src/snapshots/squawk_parser__test__values_ok.snap +++ b/crates/squawk_parser/src/snapshots/squawk_parser__test__values_ok.snap @@ -440,7 +440,7 @@ SOURCE_FILE CAST_EXPR LITERAL STRING "'192.168.0.1'" - COLON2 "::" + COLON_COLON "::" PATH_TYPE PATH PATH_SEGMENT diff --git a/crates/squawk_parser/src/syntax_kind.rs b/crates/squawk_parser/src/syntax_kind.rs index fdcf4243..9c3e4980 100644 --- a/crates/squawk_parser/src/syntax_kind.rs +++ b/crates/squawk_parser/src/syntax_kind.rs @@ -1,1500 +1,6 @@ -// based on https://github.com/rust-lang/rust-analyzer/blob/d8887c0758bbd2d5f752d5bd405d4491e90e7ed6/crates/parser/src/syntax_kind/generated.rs -#![allow(bad_style, missing_docs, clippy::upper_case_acronyms)] +// based on https://github.com/rust-lang/rust-analyzer/blob/d8887c0758bbd2d5f752d5bd405d4491e90e7ed6/crates/parser/src/syntax_kind.rs -use crate::token_set::TokenSet; -#[doc = r" The kind of syntax node, e.g. `IDENT`, `SELECT_KW`, or `STRUCT`."] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] -#[repr(u16)] -/// Needs to be compatible with [`rowan::SyntaxKind`] -pub enum SyntaxKind { - #[doc(hidden)] - TOMBSTONE, - #[doc(hidden)] - EOF, - - // symbols - /// `;` - SEMICOLON, - /// `,` - COMMA, - /// `(` - L_PAREN, - /// `)` - R_PAREN, - /// `[` - L_BRACK, - /// `]` - R_BRACK, - /// `<` - L_ANGLE, - /// `>` - R_ANGLE, - /// `@` - AT, - /// `#` - POUND, - /// `~` - TILDE, - /// `?` - QUESTION, - /// `&` - AMP, - /// `|` - PIPE, - /// `+` - PLUS, - /// `*` - STAR, - /// `/` - SLASH, - /// `^` - CARET, - /// `%` - PERCENT, - /// `.` - DOT, - /// `:` - COLON, - /// `::` - COLON2, - /// `:=` - COLONEQ, - /// `=` - EQ, - /// `=>` - /// Used for `NAMED_ARG` - FAT_ARROW, - /// ``` - /// ` - /// ``` - BACKTICK, - /// `!` - BANG, - /// `!=` - NEQ, - /// `<>` - NEQB, - /// `-` - MINUS, - /// `<=` - LTEQ, - /// `>=` - GTEQ, - // catch all for custom operators - CUSTOM_OP, - - // keywords -- generated via: cargo xtrask generate-keywords - /// `abort` - ABORT_KW, - /// `absent` - ABSENT_KW, - /// `absolute` - ABSOLUTE_KW, - /// `access` - ACCESS_KW, - /// `action` - ACTION_KW, - /// `add` - ADD_KW, - /// `admin` - ADMIN_KW, - /// `after` - AFTER_KW, - /// `aggregate` - AGGREGATE_KW, - /// `all` - ALL_KW, - /// `also` - ALSO_KW, - /// `alter` - ALTER_KW, - /// `always` - ALWAYS_KW, - /// `analyse` - ANALYSE_KW, - /// `analyze` - ANALYZE_KW, - /// `and` - AND_KW, - /// `any` - ANY_KW, - /// `array` - ARRAY_KW, - /// `as` - AS_KW, - /// `asc` - ASC_KW, - /// `asensitive` - ASENSITIVE_KW, - /// `assertion` - ASSERTION_KW, - /// `assignment` - ASSIGNMENT_KW, - /// `asymmetric` - ASYMMETRIC_KW, - /// `at` - AT_KW, - /// `atomic` - ATOMIC_KW, - /// `attach` - ATTACH_KW, - /// `attribute` - ATTRIBUTE_KW, - /// `authorization` - AUTHORIZATION_KW, - /// `backward` - BACKWARD_KW, - /// `before` - BEFORE_KW, - /// `begin` - BEGIN_KW, - /// `between` - BETWEEN_KW, - /// `bigint` - BIGINT_KW, - /// `binary` - BINARY_KW, - /// `bit` - BIT_KW, - /// `boolean` - BOOLEAN_KW, - /// `both` - BOTH_KW, - /// `breadth` - BREADTH_KW, - /// `by` - BY_KW, - /// `cache` - CACHE_KW, - /// `call` - CALL_KW, - /// `called` - CALLED_KW, - /// `cascade` - CASCADE_KW, - /// `cascaded` - CASCADED_KW, - /// `case` - CASE_KW, - /// `cast` - CAST_KW, - /// `catalog` - CATALOG_KW, - /// `chain` - CHAIN_KW, - /// `char` - CHAR_KW, - /// `character` - CHARACTER_KW, - /// `characteristics` - CHARACTERISTICS_KW, - /// `check` - CHECK_KW, - /// `checkpoint` - CHECKPOINT_KW, - /// `class` - CLASS_KW, - /// `close` - CLOSE_KW, - /// `cluster` - CLUSTER_KW, - /// `coalesce` - COALESCE_KW, - /// `collate` - COLLATE_KW, - /// `collation` - COLLATION_KW, - /// `column` - COLUMN_KW, - /// `columns` - COLUMNS_KW, - /// `comment` - COMMENT_KW, - /// `comments` - COMMENTS_KW, - /// `commit` - COMMIT_KW, - /// `committed` - COMMITTED_KW, - /// `compression` - COMPRESSION_KW, - /// `concurrently` - CONCURRENTLY_KW, - /// `conditional` - CONDITIONAL_KW, - /// `configuration` - CONFIGURATION_KW, - /// `conflict` - CONFLICT_KW, - /// `connection` - CONNECTION_KW, - /// `constraint` - CONSTRAINT_KW, - /// `constraints` - CONSTRAINTS_KW, - /// `content` - CONTENT_KW, - /// `continue` - CONTINUE_KW, - /// `conversion` - CONVERSION_KW, - /// `copy` - COPY_KW, - /// `cost` - COST_KW, - /// `create` - CREATE_KW, - /// `cross` - CROSS_KW, - /// `csv` - CSV_KW, - /// `cube` - CUBE_KW, - /// `current` - CURRENT_KW, - /// `current_catalog` - CURRENT_CATALOG_KW, - /// `current_date` - CURRENT_DATE_KW, - /// `current_role` - CURRENT_ROLE_KW, - /// `current_schema` - CURRENT_SCHEMA_KW, - /// `current_time` - CURRENT_TIME_KW, - /// `current_timestamp` - CURRENT_TIMESTAMP_KW, - /// `current_user` - CURRENT_USER_KW, - /// `cursor` - CURSOR_KW, - /// `cycle` - CYCLE_KW, - /// `data` - DATA_KW, - /// `database` - DATABASE_KW, - /// `day` - DAY_KW, - /// `deallocate` - DEALLOCATE_KW, - /// `dec` - DEC_KW, - /// `decimal` - DECIMAL_KW, - /// `declare` - DECLARE_KW, - /// `default` - DEFAULT_KW, - /// `defaults` - DEFAULTS_KW, - /// `deferrable` - DEFERRABLE_KW, - /// `deferred` - DEFERRED_KW, - /// `definer` - DEFINER_KW, - /// `delete` - DELETE_KW, - /// `delimiter` - DELIMITER_KW, - /// `delimiters` - DELIMITERS_KW, - /// `depends` - DEPENDS_KW, - /// `depth` - DEPTH_KW, - /// `desc` - DESC_KW, - /// `detach` - DETACH_KW, - /// `dictionary` - DICTIONARY_KW, - /// `disable` - DISABLE_KW, - /// `discard` - DISCARD_KW, - /// `distinct` - DISTINCT_KW, - /// `do` - DO_KW, - /// `document` - DOCUMENT_KW, - /// `domain` - DOMAIN_KW, - /// `double` - DOUBLE_KW, - /// `drop` - DROP_KW, - /// `each` - EACH_KW, - /// `else` - ELSE_KW, - /// `empty` - EMPTY_KW, - /// `enable` - ENABLE_KW, - /// `encoding` - ENCODING_KW, - /// `encrypted` - ENCRYPTED_KW, - /// `end` - END_KW, - /// `enum` - ENUM_KW, - /// `error` - ERROR_KW, - /// `escape` - ESCAPE_KW, - /// `event` - EVENT_KW, - /// `except` - EXCEPT_KW, - /// `exclude` - EXCLUDE_KW, - /// `excluding` - EXCLUDING_KW, - /// `exclusive` - EXCLUSIVE_KW, - /// `execute` - EXECUTE_KW, - /// `exists` - EXISTS_KW, - /// `explain` - EXPLAIN_KW, - /// `expression` - EXPRESSION_KW, - /// `extension` - EXTENSION_KW, - /// `external` - EXTERNAL_KW, - /// `extract` - EXTRACT_KW, - /// `false` - FALSE_KW, - /// `family` - FAMILY_KW, - /// `fetch` - FETCH_KW, - /// `filter` - FILTER_KW, - /// `finalize` - FINALIZE_KW, - /// `first` - FIRST_KW, - /// `float` - FLOAT_KW, - /// `following` - FOLLOWING_KW, - /// `for` - FOR_KW, - /// `force` - FORCE_KW, - /// `foreign` - FOREIGN_KW, - /// `format` - FORMAT_KW, - /// `forward` - FORWARD_KW, - /// `freeze` - FREEZE_KW, - /// `from` - FROM_KW, - /// `full` - FULL_KW, - /// `function` - FUNCTION_KW, - /// `functions` - FUNCTIONS_KW, - /// `generated` - GENERATED_KW, - /// `global` - GLOBAL_KW, - /// `grant` - GRANT_KW, - /// `granted` - GRANTED_KW, - /// `greatest` - GREATEST_KW, - /// `group` - GROUP_KW, - /// `grouping` - GROUPING_KW, - /// `groups` - GROUPS_KW, - /// `handler` - HANDLER_KW, - /// `having` - HAVING_KW, - /// `header` - HEADER_KW, - /// `hold` - HOLD_KW, - /// `hour` - HOUR_KW, - /// `identity` - IDENTITY_KW, - /// `if` - IF_KW, - /// `ilike` - ILIKE_KW, - /// `immediate` - IMMEDIATE_KW, - /// `immutable` - IMMUTABLE_KW, - /// `implicit` - IMPLICIT_KW, - /// `import` - IMPORT_KW, - /// `in` - IN_KW, - /// `include` - INCLUDE_KW, - /// `including` - INCLUDING_KW, - /// `increment` - INCREMENT_KW, - /// `indent` - INDENT_KW, - /// `index` - INDEX_KW, - /// `indexes` - INDEXES_KW, - /// `inherit` - INHERIT_KW, - /// `inherits` - INHERITS_KW, - /// `initially` - INITIALLY_KW, - /// `inline` - INLINE_KW, - /// `inner` - INNER_KW, - /// `inout` - INOUT_KW, - /// `input` - INPUT_KW, - /// `insensitive` - INSENSITIVE_KW, - /// `insert` - INSERT_KW, - /// `instead` - INSTEAD_KW, - /// `int` - INT_KW, - /// `integer` - INTEGER_KW, - /// `intersect` - INTERSECT_KW, - /// `interval` - INTERVAL_KW, - /// `into` - INTO_KW, - /// `invoker` - INVOKER_KW, - /// `is` - IS_KW, - /// `isnull` - ISNULL_KW, - /// `isolation` - ISOLATION_KW, - /// `join` - JOIN_KW, - /// `json` - JSON_KW, - /// `json_array` - JSON_ARRAY_KW, - /// `json_arrayagg` - JSON_ARRAYAGG_KW, - /// `json_exists` - JSON_EXISTS_KW, - /// `json_object` - JSON_OBJECT_KW, - /// `json_objectagg` - JSON_OBJECTAGG_KW, - /// `json_query` - JSON_QUERY_KW, - /// `json_scalar` - JSON_SCALAR_KW, - /// `json_serialize` - JSON_SERIALIZE_KW, - /// `json_table` - JSON_TABLE_KW, - /// `json_value` - JSON_VALUE_KW, - /// `keep` - KEEP_KW, - /// `key` - KEY_KW, - /// `keys` - KEYS_KW, - /// `label` - LABEL_KW, - /// `language` - LANGUAGE_KW, - /// `large` - LARGE_KW, - /// `last` - LAST_KW, - /// `lateral` - LATERAL_KW, - /// `leading` - LEADING_KW, - /// `leakproof` - LEAKPROOF_KW, - /// `least` - LEAST_KW, - /// `left` - LEFT_KW, - /// `level` - LEVEL_KW, - /// `like` - LIKE_KW, - /// `limit` - LIMIT_KW, - /// `listen` - LISTEN_KW, - /// `load` - LOAD_KW, - /// `local` - LOCAL_KW, - /// `localtime` - LOCALTIME_KW, - /// `localtimestamp` - LOCALTIMESTAMP_KW, - /// `location` - LOCATION_KW, - /// `lock` - LOCK_KW, - /// `locked` - LOCKED_KW, - /// `logged` - LOGGED_KW, - /// `mapping` - MAPPING_KW, - /// `match` - MATCH_KW, - /// `matched` - MATCHED_KW, - /// `materialized` - MATERIALIZED_KW, - /// `maxvalue` - MAXVALUE_KW, - /// `merge` - MERGE_KW, - /// `merge_action` - MERGE_ACTION_KW, - /// `method` - METHOD_KW, - /// `minute` - MINUTE_KW, - /// `minvalue` - MINVALUE_KW, - /// `mode` - MODE_KW, - /// `month` - MONTH_KW, - /// `move` - MOVE_KW, - /// `name` - NAME_KW, - /// `names` - NAMES_KW, - /// `national` - NATIONAL_KW, - /// `natural` - NATURAL_KW, - /// `nchar` - NCHAR_KW, - /// `nested` - NESTED_KW, - /// `new` - NEW_KW, - /// `next` - NEXT_KW, - /// `nfc` - NFC_KW, - /// `nfd` - NFD_KW, - /// `nfkc` - NFKC_KW, - /// `nfkd` - NFKD_KW, - /// `no` - NO_KW, - /// `none` - NONE_KW, - /// `normalize` - NORMALIZE_KW, - /// `normalized` - NORMALIZED_KW, - /// `not` - NOT_KW, - /// `nothing` - NOTHING_KW, - /// `notify` - NOTIFY_KW, - /// `notnull` - NOTNULL_KW, - /// `nowait` - NOWAIT_KW, - /// `null` - NULL_KW, - /// `nullif` - NULLIF_KW, - /// `nulls` - NULLS_KW, - /// `numeric` - NUMERIC_KW, - /// `object` - OBJECT_KW, - /// `of` - OF_KW, - /// `off` - OFF_KW, - /// `offset` - OFFSET_KW, - /// `oids` - OIDS_KW, - /// `old` - OLD_KW, - /// `omit` - OMIT_KW, - /// `on` - ON_KW, - /// `only` - ONLY_KW, - /// `operator` - OPERATOR_KW, - /// `option` - OPTION_KW, - /// `options` - OPTIONS_KW, - /// `or` - OR_KW, - /// `order` - ORDER_KW, - /// `ordinality` - ORDINALITY_KW, - /// `others` - OTHERS_KW, - /// `out` - OUT_KW, - /// `outer` - OUTER_KW, - /// `over` - OVER_KW, - /// `overlaps` - OVERLAPS_KW, - /// `overlay` - OVERLAY_KW, - /// `overriding` - OVERRIDING_KW, - /// `owned` - OWNED_KW, - /// `owner` - OWNER_KW, - /// `parallel` - PARALLEL_KW, - /// `parameter` - PARAMETER_KW, - /// `parser` - PARSER_KW, - /// `partial` - PARTIAL_KW, - /// `partition` - PARTITION_KW, - /// `passing` - PASSING_KW, - /// `password` - PASSWORD_KW, - /// `path` - PATH_KW, - /// `period` - PERIOD_KW, - /// `placing` - PLACING_KW, - /// `plan` - PLAN_KW, - /// `plans` - PLANS_KW, - /// `policy` - POLICY_KW, - /// `position` - POSITION_KW, - /// `preceding` - PRECEDING_KW, - /// `precision` - PRECISION_KW, - /// `prepare` - PREPARE_KW, - /// `prepared` - PREPARED_KW, - /// `preserve` - PRESERVE_KW, - /// `primary` - PRIMARY_KW, - /// `prior` - PRIOR_KW, - /// `privileges` - PRIVILEGES_KW, - /// `procedural` - PROCEDURAL_KW, - /// `procedure` - PROCEDURE_KW, - /// `procedures` - PROCEDURES_KW, - /// `program` - PROGRAM_KW, - /// `publication` - PUBLICATION_KW, - /// `quote` - QUOTE_KW, - /// `quotes` - QUOTES_KW, - /// `range` - RANGE_KW, - /// `read` - READ_KW, - /// `real` - REAL_KW, - /// `reassign` - REASSIGN_KW, - /// `recursive` - RECURSIVE_KW, - /// `ref` - REF_KW, - /// `references` - REFERENCES_KW, - /// `referencing` - REFERENCING_KW, - /// `refresh` - REFRESH_KW, - /// `reindex` - REINDEX_KW, - /// `relative` - RELATIVE_KW, - /// `release` - RELEASE_KW, - /// `rename` - RENAME_KW, - /// `repeatable` - REPEATABLE_KW, - /// `replace` - REPLACE_KW, - /// `replica` - REPLICA_KW, - /// `reset` - RESET_KW, - /// `restart` - RESTART_KW, - /// `restrict` - RESTRICT_KW, - /// `return` - RETURN_KW, - /// `returning` - RETURNING_KW, - /// `returns` - RETURNS_KW, - /// `revoke` - REVOKE_KW, - /// `right` - RIGHT_KW, - /// `role` - ROLE_KW, - /// `rollback` - ROLLBACK_KW, - /// `rollup` - ROLLUP_KW, - /// `routine` - ROUTINE_KW, - /// `routines` - ROUTINES_KW, - /// `row` - ROW_KW, - /// `rows` - ROWS_KW, - /// `rule` - RULE_KW, - /// `savepoint` - SAVEPOINT_KW, - /// `scalar` - SCALAR_KW, - /// `schema` - SCHEMA_KW, - /// `schemas` - SCHEMAS_KW, - /// `scroll` - SCROLL_KW, - /// `search` - SEARCH_KW, - /// `second` - SECOND_KW, - /// `security` - SECURITY_KW, - /// `select` - SELECT_KW, - /// `sequence` - SEQUENCE_KW, - /// `sequences` - SEQUENCES_KW, - /// `serializable` - SERIALIZABLE_KW, - /// `server` - SERVER_KW, - /// `session` - SESSION_KW, - /// `session_user` - SESSION_USER_KW, - /// `set` - SET_KW, - /// `setof` - SETOF_KW, - /// `sets` - SETS_KW, - /// `share` - SHARE_KW, - /// `show` - SHOW_KW, - /// `similar` - SIMILAR_KW, - /// `simple` - SIMPLE_KW, - /// `skip` - SKIP_KW, - /// `smallint` - SMALLINT_KW, - /// `snapshot` - SNAPSHOT_KW, - /// `some` - SOME_KW, - /// `source` - SOURCE_KW, - /// `sql` - SQL_KW, - /// `stable` - STABLE_KW, - /// `standalone` - STANDALONE_KW, - /// `start` - START_KW, - /// `statement` - STATEMENT_KW, - /// `statistics` - STATISTICS_KW, - /// `stdin` - STDIN_KW, - /// `stdout` - STDOUT_KW, - /// `storage` - STORAGE_KW, - /// `stored` - STORED_KW, - /// `strict` - STRICT_KW, - /// `string` - STRING_KW, - /// `strip` - STRIP_KW, - /// `subscription` - SUBSCRIPTION_KW, - /// `substring` - SUBSTRING_KW, - /// `support` - SUPPORT_KW, - /// `symmetric` - SYMMETRIC_KW, - /// `sysid` - SYSID_KW, - /// `system` - SYSTEM_KW, - /// `system_user` - SYSTEM_USER_KW, - /// `table` - TABLE_KW, - /// `tables` - TABLES_KW, - /// `tablesample` - TABLESAMPLE_KW, - /// `tablespace` - TABLESPACE_KW, - /// `target` - TARGET_KW, - /// `temp` - TEMP_KW, - /// `template` - TEMPLATE_KW, - /// `temporary` - TEMPORARY_KW, - /// `text` - TEXT_KW, - /// `then` - THEN_KW, - /// `ties` - TIES_KW, - /// `time` - TIME_KW, - /// `timestamp` - TIMESTAMP_KW, - /// `to` - TO_KW, - /// `trailing` - TRAILING_KW, - /// `transaction` - TRANSACTION_KW, - /// `transform` - TRANSFORM_KW, - /// `treat` - TREAT_KW, - /// `trigger` - TRIGGER_KW, - /// `trim` - TRIM_KW, - /// `true` - TRUE_KW, - /// `truncate` - TRUNCATE_KW, - /// `trusted` - TRUSTED_KW, - /// `type` - TYPE_KW, - /// `types` - TYPES_KW, - /// `uescape` - UESCAPE_KW, - /// `unbounded` - UNBOUNDED_KW, - /// `uncommitted` - UNCOMMITTED_KW, - /// `unconditional` - UNCONDITIONAL_KW, - /// `unencrypted` - UNENCRYPTED_KW, - /// `union` - UNION_KW, - /// `unique` - UNIQUE_KW, - /// `unknown` - UNKNOWN_KW, - /// `unlisten` - UNLISTEN_KW, - /// `unlogged` - UNLOGGED_KW, - /// `until` - UNTIL_KW, - /// `update` - UPDATE_KW, - /// `user` - USER_KW, - /// `using` - USING_KW, - /// `vacuum` - VACUUM_KW, - /// `valid` - VALID_KW, - /// `validate` - VALIDATE_KW, - /// `validator` - VALIDATOR_KW, - /// `value` - VALUE_KW, - /// `values` - VALUES_KW, - /// `varchar` - VARCHAR_KW, - /// `variadic` - VARIADIC_KW, - /// `varying` - VARYING_KW, - /// `verbose` - VERBOSE_KW, - /// `version` - VERSION_KW, - /// `view` - VIEW_KW, - /// `views` - VIEWS_KW, - /// `volatile` - VOLATILE_KW, - /// `when` - WHEN_KW, - /// `where` - WHERE_KW, - /// `whitespace` - WHITESPACE_KW, - /// `window` - WINDOW_KW, - /// `with` - WITH_KW, - /// `within` - WITHIN_KW, - /// `without` - WITHOUT_KW, - /// `work` - WORK_KW, - /// `wrapper` - WRAPPER_KW, - /// `write` - WRITE_KW, - /// `xml` - XML_KW, - /// `xmlattributes` - XMLATTRIBUTES_KW, - /// `xmlconcat` - XMLCONCAT_KW, - /// `xmlelement` - XMLELEMENT_KW, - /// `xmlexists` - XMLEXISTS_KW, - /// `xmlforest` - XMLFOREST_KW, - /// `xmlnamespaces` - XMLNAMESPACES_KW, - /// `xmlparse` - XMLPARSE_KW, - /// `xmlpi` - XMLPI_KW, - /// `xmlroot` - XMLROOT_KW, - /// `xmlserialize` - XMLSERIALIZE_KW, - /// `xmltable` - XMLTABLE_KW, - /// `year` - YEAR_KW, - /// `yes` - YES_KW, - /// `zone` - ZONE_KW, - - // literals - /// `1.0` - FLOAT_NUMBER, - /// `1` - INT_NUMBER, - /// `'foo'` - STRING, - /// `X'1FF'`, `U&'d\0061t\+000061'` - /// - /// see: - /// see: - BYTE_STRING, - /// `B'1001'` - /// - /// see: - BIT_STRING, - /// `$$Dianne's horse$$` - /// - /// see: - DOLLAR_QUOTED_STRING, - /// `E'foo'` - /// - /// see: - ESC_STRING, - /// `-- foo` - /// or - /// `/* foo */` - /// - /// see: - COMMENT, - IDENT, - PARAM, - ERROR, - WHITESPACE, - - // nodes - /// `100, bar, buzz` - ARG_LIST, - ARG, - PARAM_LIST, - COLLATE, - TARGET_LIST, - TARGET, - ARRAY_EXPR, - IS_NULL, - IS_NOT, - IS_NOT_DISTINCT_FROM, - /// - /// Left assoc in postgres/gram.y - /// Same precedence as operators - OPERATOR_CALL, - /// `at time zone` - AT_TIME_ZONE, - SIMILAR_TO, - IS_DISTINCT_FROM, - NOT_LIKE, - NOT_IN, - BIN_EXPR, - POSTFIX_EXPR, - /// `foo()` - CALL_EXPR, - BETWEEN_EXPR, - /// `foo::bar`, `cast(foo as bar)`, `treat(foo as bar)`, or `numeric '123'` - CAST_EXPR, - CASE_EXPR, - ALIAS, - /// `foo.bar` - FIELD_EXPR, - /// `foo[1]` - INDEX_EXPR, - LITERAL, - NAME, - /// `a := b`, `a => b` - NAMED_ARG, - /// `a: b`, `a value b` - JSON_KEY_VALUE, - PAREN_EXPR, - PATH, - PATH_SEGMENT, - PATH_TYPE, - CHAR_TYPE, - BIT_TYPE, - PERCENT_TYPE, - DOUBLE_TYPE, - TIME_TYPE, - INTERVAL_TYPE, - ARRAY_TYPE, - PERCENT_TYPE_CLAUSE, - WITH_TIMEZONE, - WITHOUT_TIMEZONE, - PREFIX_EXPR, - COLUMN, - SOURCE_FILE, - RET_TYPE, - STMT, - ALTER_AGGREGATE_STMT, - ALTER_COLLATION_STMT, - ALTER_CONVERSION_STMT, - ALTER_DATABASE_STMT, - ALTER_DEFAULT_PRIVILEGES_STMT, - ALTER_DOMAIN_STMT, - ALTER_EVENT_TRIGGER_STMT, - ALTER_EXTENSION_STMT, - ALTER_FOREIGN_DATA_WRAPPER_STMT, - ALTER_FOREIGN_TABLE_STMT, - ALTER_FUNCTION_STMT, - ALTER_GROUP_STMT, - ALTER_INDEX_STMT, - ALTER_LANGUAGE_STMT, - ALTER_LARGE_OBJECT_STMT, - ALTER_MATERIALIZED_VIEW_STMT, - ALTER_OPERATOR_STMT, - ALTER_OPERATOR_CLASS_STMT, - ALTER_OPERATOR_FAMILY_STMT, - ALTER_POLICY_STMT, - ALTER_PROCEDURE_STMT, - ALTER_PUBLICATION_STMT, - ALTER_ROLE_STMT, - ALTER_ROUTINE_STMT, - ALTER_RULE_STMT, - ALTER_SCHEMA_STMT, - ALTER_SEQUENCE_STMT, - ALTER_SERVER_STMT, - ALTER_STATISTICS_STMT, - ALTER_SUBSCRIPTION_STMT, - ALTER_SYSTEM_STMT, - ALTER_TABLESPACE_STMT, - ALTER_TEXT_SEARCH_CONFIGURATION_STMT, - ALTER_TEXT_SEARCH_DICTIONARY_STMT, - ALTER_TEXT_SEARCH_PARSER_STMT, - ALTER_TEXT_SEARCH_TEMPLATE_STMT, - ALTER_TRIGGER_STMT, - ALTER_TYPE_STMT, - ALTER_USER_STMT, - ALTER_USER_MAPPING_STMT, - ALTER_VIEW_STMT, - ANALYZE_STMT, - CLUSTER_STMT, - COMMENT_STMT, - COMMIT_STMT, - CREATE_EXTENSION_STMT, - CREATE_ACCESS_METHOD_STMT, - CREATE_AGGREGATE_STMT, - CREATE_CAST_STMT, - CREATE_COLLATION_STMT, - CREATE_CONVERSION_STMT, - CREATE_DATABASE_STMT, - CREATE_DOMAIN_STMT, - CREATE_EVENT_TRIGGER_STMT, - CREATE_FOREIGN_DATA_WRAPPER_STMT, - CREATE_FOREIGN_TABLE_STMT, - CREATE_GROUP_STMT, - CREATE_LANGUAGE_STMT, - CREATE_MATERIALIZED_VIEW_STMT, - CREATE_OPERATOR_STMT, - CREATE_OPERATOR_CLASS_STMT, - CREATE_OPERATOR_FAMILY_STMT, - CREATE_POLICY_STMT, - CREATE_PROCEDURE_STMT, - CREATE_PUBLICATION_STMT, - CREATE_ROLE_STMT, - CREATE_RULE_STMT, - CREATE_SEQUENCE_STMT, - CREATE_SERVER_STMT, - CREATE_STATISTICS_STMT, - CREATE_SUBSCRIPTION_STMT, - CREATE_TABLE_AS_STMT, - CREATE_TABLESPACE_STMT, - CREATE_TEXT_SEARCH_CONFIGURATION_STMT, - CREATE_TEXT_SEARCH_DICTIONARY_STMT, - CREATE_TEXT_SEARCH_PARSER_STMT, - CREATE_TEXT_SEARCH_TEMPLATE_STMT, - CREATE_TRANSFORM_STMT, - CREATE_INDEX_STMT, - CREATE_TYPE_STMT, - CREATE_TRIGGER_STMT, - CREATE_FUNCTION_STMT, - PARAM_IN, - PARAM_OUT, - PARAM_INOUT, - PARAM_VARIADIC, - BEGIN_FUNC_OPTION, - RETURN_FUNC_OPTION, - AS_FUNC_OPTION, - SET_FUNC_OPTION, - SUPPORT_FUNC_OPTION, - ROWS_FUNC_OPTION, - COST_FUNC_OPTION, - PARALLEL_FUNC_OPTION, - SECURITY_FUNC_OPTION, - STRICT_FUNC_OPTION, - LEAKPROOF_FUNC_OPTION, - RESET_FUNC_OPTION, - VOLATILITY_FUNC_OPTION, - WINDOW_FUNC_OPTION, - TRANSFORM_FUNC_OPTION, - LANGUAGE_FUNC_OPTION, - PARAM_DEFAULT, - FUNC_OPTION_LIST, - IF_EXISTS, - IF_NOT_EXISTS, - OR_REPLACE, - DROP_INDEX_STMT, - DROP_TRIGGER_STMT, - BEGIN_STMT, - SHOW_STMT, - SET_STMT, - PREPARE_TRANSACTION_STMT, - DROP_DATABASE_STMT, - DROP_TYPE_STMT, - CALL_STMT, - TRUNCATE_STMT, - MOVE_STMT, - FETCH_STMT, - DECLARE_STMT, - DO_STMT, - DISCARD_STMT, - RESET_STMT, - LISTEN_STMT, - LOAD_STMT, - DEALLOCATE_STMT, - CHECKPOINT_STMT, - PREPARE_STMT, - UNLISTEN_STMT, - NOTIFY_STMT, - CLOSE_STMT, - VACUUM_STMT, - COPY_STMT, - DELETE_STMT, - MERGE_STMT, - LOCK_STMT, - EXPLAIN_STMT, - DROP_USER_STMT, - DROP_TRANSFORM_STMT, - DROP_TEXT_SEARCH_TEMPLATE_STMT, - DROP_TEXT_SEARCH_PARSER_STMT, - DROP_TEXT_SEARCH_DICT_STMT, - DROP_TEXT_SEARCH_CONFIG_STMT, - DROP_TABLESPACE_STMT, - DROP_SUBSCRIPTION_STMT, - DROP_STATISTICS_STMT, - DROP_SERVER_STMT, - DROP_SEQUENCE_STMT, - DROP_RULE_STMT, - DROP_ROUTINE_STMT, - DROP_ROLE_STMT, - DROP_PUBLICATION_STMT, - DROP_PROCEDURE_STMT, - DROP_POLICY_STMT, - DROP_OWNED_STMT, - DROP_OPERATOR_FAMILY_STMT, - DROP_OPERATOR_CLASS_STMT, - DROP_MATERIALIZED_VIEW_STMT, - DROP_OPERATOR_STMT, - DROP_LANGUAGE_STMT, - DROP_GROUP_STMT, - DROP_FUNCTION_STMT, - DROP_FOREIGN_TABLE_STMT, - DROP_FOREIGN_DATA_WRAPPER_STMT, - DROP_EXTENSION_STMT, - DROP_EVENT_TRIGGER_STMT, - DROP_DOMAIN_STMT, - DROP_CONVERSION_STMT, - DROP_COLLATION_STMT, - DROP_CAST_STMT, - DROP_AGGREGATE_STMT, - DROP_ACCESS_METHOD_STMT, - DROP_USER_MAPPING_STMT, - IMPORT_FOREIGN_SCHEMA, - EXECUTE_STMT, - CREATE_VIEW_STMT, - SAVEPOINT_STMT, - RELEASE_SAVEPOINT_STMT, - DROP_SCHEMA_STMT, - DROP_VIEW_STMT, - REINDEX_STMT, - UPDATE_STMT, - ROLLBACK_STMT, - INSERT_STMT, - CREATE_SCHEMA_STMT, - SELECT, - TABLE_STMT, - VALUES, - SELECT_INTO_STMT, - SECURITY_LABEL_STMT, - REVOKE_STMT, - GRANT_STMT, - REFRESH_STMT, - REASSIGN_STMT, - SET_SESSION_AUTH_STMT, - CREATE_USER_MAPPING_STMT, - CREATE_USER_STMT, - SET_ROLE_STMT, - SET_CONSTRAINTS_STMT, - SET_TRANSACTION_STMT, - INTO_CLAUSE, - COMPOUND_SELECT, - DROP_TABLE, - JOIN, - CREATE_TABLE, - ALTER_TABLE, - WINDOW_DEF, - JSON_VALUE_EXPR, - JSON_FORMAT_CLAUSE, - JSON_RETURNING_CLAUSE, - JSON_QUOTES_CLAUSE, - JSON_WRAPPER_BEHAVIOR_CLAUSE, - JSON_BEHAVIOR_CLAUSE, - JSON_PASSING_CLAUSE, - JSON_ON_ERROR_CLAUSE, - JSON_NULL_CLAUSE, - JSON_KEYS_UNIQUE_CLAUSE, - SELECT_CLAUSE, - LIKE_CLAUSE, - REFERENCES_CONSTRAINT, - PRIMARY_KEY_CONSTRAINT, - FOREIGN_KEY_CONSTRAINT, - EXCLUDE_CONSTRAINT, - UNIQUE_CONSTRAINT, - GENERATED_CONSTRAINT, - DEFAULT_CONSTRAINT, - CHECK_CONSTRAINT, - NULL_CONSTRAINT, - NOT_NULL_CONSTRAINT, - INDEX_PARAMS, - CONSTRAINT_INDEX_TABLESPACE, - CONSTRAINT_STORAGE_PARAMS, - CONSTRAINT_INCLUDE_CLAUSE, - CONSTRAINT_WHERE_CLAUSE, - CONSTRAINT_INDEX_METHOD, - CONSTRAINT_EXCLUSIONS, - DEFERRABLE_CONSTRAINT_OPTION, - NOT_DEFERRABLE_CONSTRAINT_OPTION, - INITALLY_DEFERRED_CONSTRAINT_OPTION, - INITIALLY_IMMEDIATE_CONSTRAINT_OPTION, - CONSTRAINT_OPTION_LIST, - SEQUENCE_OPTION_LIST, - USING_INDEX, - // alter table actions - VALIDATE_CONSTRAINT, - REPLICA_IDENTITY, - OF_TYPE, - NOT_OF, - FORCE_RLS, - NO_FORCE_RLS, - INHERIT, - NO_INHERIT, - ENABLE_TRIGGER, - ENABLE_REPLICA_TRIGGER, - ENABLE_REPLICA_RULE, - ENABLE_ALWAYS_TRIGGER, - ENABLE_ALWAYS_RULE, - ENABLE_RULE, - ENABLE_RLS, - DISABLE_TRIGGER, - DISABLE_RLS, - DISABLE_RULE, - CLUSTER_ON, - OWNER_TO, - DETACH_PARTITION, - DROP_CONSTRAINT, - DROP_COLUMN, - ADD_CONSTRAINT, - ADD_COLUMN, - ATTACH_PARTITION, - TABLE_LIST, - SET_SCHEMA, - SET_TABLESPACE, - SET_WITHOUT_CLUSTER, - SET_WITHOUT_OIDS, - SET_ACCESS_METHOD, - SET_LOGGED, - SET_UNLOGGED, - SET_STORAGE_PARAMS, - RESET_STORAGE_PARAMS, - RENAME_TABLE, - RENAME_CONSTRAINT, - RENAME_COLUMN, - RENAME_TO, - NOT_VALID, - ALTER_CONSTRAINT, - ALTER_COLUMN, - // alter table actions end - // alter column options - DROP_DEFAULT, - DROP_EXPRESSION, - DROP_IDENTITY, - DROP_NOT_NULL, - RESTART, - ADD_GENERATED, - RESET_OPTIONS, - SET_TYPE, - SET_GENERATED_OPTIONS, - SET_GENERATED, - SET_SEQUENCE_OPTION, - SET_DEFAULT, - SET_EXPRESSION, - SET_STATISTICS, - SET_OPTIONS, - SET_OPTIONS_LIST, - SET_STORAGE, - SET_COMPRESSION, - SET_NOT_NULL, - // alter column options end - TABLE_ARGS, - COLUMN_LIST, - WHEN_CLAUSE, - USING_CLAUSE, - WITHIN_CLAUSE, - FILTER_CLAUSE, - OVER_CLAUSE, - DISTINCT_CLAUSE, - WITH_TABLE, - WITH_CLAUSE, - FROM_CLAUSE, - WHERE_CLAUSE, - GROUP_BY_CLAUSE, - HAVING_CLAUSE, - WINDOW_CLAUSE, - LIMIT_CLAUSE, - OFFSET_CLAUSE, - ORDER_BY_CLAUSE, - LOCKING_CLAUSE, - TUPLE_EXPR, - NAME_REF, - #[doc(hidden)] - __LAST, -} +pub use crate::generated::syntax_kind::SyntaxKind; impl From for SyntaxKind { #[inline] @@ -1516,3166 +22,4 @@ impl SyntaxKind { pub fn is_trivia(self) -> bool { matches!(self, SyntaxKind::WHITESPACE | SyntaxKind::COMMENT) } - - // generated via: cargo xtask generate_keywords - pub(crate) fn from_keyword(ident: &str) -> Option { - let kw = if ident.eq_ignore_ascii_case("abort") { - SyntaxKind::ABORT_KW - } else if ident.eq_ignore_ascii_case("absent") { - SyntaxKind::ABSENT_KW - } else if ident.eq_ignore_ascii_case("absolute") { - SyntaxKind::ABSOLUTE_KW - } else if ident.eq_ignore_ascii_case("access") { - SyntaxKind::ACCESS_KW - } else if ident.eq_ignore_ascii_case("action") { - SyntaxKind::ACTION_KW - } else if ident.eq_ignore_ascii_case("add") { - SyntaxKind::ADD_KW - } else if ident.eq_ignore_ascii_case("admin") { - SyntaxKind::ADMIN_KW - } else if ident.eq_ignore_ascii_case("after") { - SyntaxKind::AFTER_KW - } else if ident.eq_ignore_ascii_case("aggregate") { - SyntaxKind::AGGREGATE_KW - } else if ident.eq_ignore_ascii_case("all") { - SyntaxKind::ALL_KW - } else if ident.eq_ignore_ascii_case("also") { - SyntaxKind::ALSO_KW - } else if ident.eq_ignore_ascii_case("alter") { - SyntaxKind::ALTER_KW - } else if ident.eq_ignore_ascii_case("always") { - SyntaxKind::ALWAYS_KW - } else if ident.eq_ignore_ascii_case("analyse") { - SyntaxKind::ANALYSE_KW - } else if ident.eq_ignore_ascii_case("analyze") { - SyntaxKind::ANALYZE_KW - } else if ident.eq_ignore_ascii_case("and") { - SyntaxKind::AND_KW - } else if ident.eq_ignore_ascii_case("any") { - SyntaxKind::ANY_KW - } else if ident.eq_ignore_ascii_case("array") { - SyntaxKind::ARRAY_KW - } else if ident.eq_ignore_ascii_case("as") { - SyntaxKind::AS_KW - } else if ident.eq_ignore_ascii_case("asc") { - SyntaxKind::ASC_KW - } else if ident.eq_ignore_ascii_case("asensitive") { - SyntaxKind::ASENSITIVE_KW - } else if ident.eq_ignore_ascii_case("assertion") { - SyntaxKind::ASSERTION_KW - } else if ident.eq_ignore_ascii_case("assignment") { - SyntaxKind::ASSIGNMENT_KW - } else if ident.eq_ignore_ascii_case("asymmetric") { - SyntaxKind::ASYMMETRIC_KW - } else if ident.eq_ignore_ascii_case("at") { - SyntaxKind::AT_KW - } else if ident.eq_ignore_ascii_case("atomic") { - SyntaxKind::ATOMIC_KW - } else if ident.eq_ignore_ascii_case("attach") { - SyntaxKind::ATTACH_KW - } else if ident.eq_ignore_ascii_case("attribute") { - SyntaxKind::ATTRIBUTE_KW - } else if ident.eq_ignore_ascii_case("authorization") { - SyntaxKind::AUTHORIZATION_KW - } else if ident.eq_ignore_ascii_case("backward") { - SyntaxKind::BACKWARD_KW - } else if ident.eq_ignore_ascii_case("before") { - SyntaxKind::BEFORE_KW - } else if ident.eq_ignore_ascii_case("begin") { - SyntaxKind::BEGIN_KW - } else if ident.eq_ignore_ascii_case("between") { - SyntaxKind::BETWEEN_KW - } else if ident.eq_ignore_ascii_case("bigint") { - SyntaxKind::BIGINT_KW - } else if ident.eq_ignore_ascii_case("binary") { - SyntaxKind::BINARY_KW - } else if ident.eq_ignore_ascii_case("bit") { - SyntaxKind::BIT_KW - } else if ident.eq_ignore_ascii_case("boolean") { - SyntaxKind::BOOLEAN_KW - } else if ident.eq_ignore_ascii_case("both") { - SyntaxKind::BOTH_KW - } else if ident.eq_ignore_ascii_case("breadth") { - SyntaxKind::BREADTH_KW - } else if ident.eq_ignore_ascii_case("by") { - SyntaxKind::BY_KW - } else if ident.eq_ignore_ascii_case("cache") { - SyntaxKind::CACHE_KW - } else if ident.eq_ignore_ascii_case("call") { - SyntaxKind::CALL_KW - } else if ident.eq_ignore_ascii_case("called") { - SyntaxKind::CALLED_KW - } else if ident.eq_ignore_ascii_case("cascade") { - SyntaxKind::CASCADE_KW - } else if ident.eq_ignore_ascii_case("cascaded") { - SyntaxKind::CASCADED_KW - } else if ident.eq_ignore_ascii_case("case") { - SyntaxKind::CASE_KW - } else if ident.eq_ignore_ascii_case("cast") { - SyntaxKind::CAST_KW - } else if ident.eq_ignore_ascii_case("catalog") { - SyntaxKind::CATALOG_KW - } else if ident.eq_ignore_ascii_case("chain") { - SyntaxKind::CHAIN_KW - } else if ident.eq_ignore_ascii_case("char") { - SyntaxKind::CHAR_KW - } else if ident.eq_ignore_ascii_case("character") { - SyntaxKind::CHARACTER_KW - } else if ident.eq_ignore_ascii_case("characteristics") { - SyntaxKind::CHARACTERISTICS_KW - } else if ident.eq_ignore_ascii_case("check") { - SyntaxKind::CHECK_KW - } else if ident.eq_ignore_ascii_case("checkpoint") { - SyntaxKind::CHECKPOINT_KW - } else if ident.eq_ignore_ascii_case("class") { - SyntaxKind::CLASS_KW - } else if ident.eq_ignore_ascii_case("close") { - SyntaxKind::CLOSE_KW - } else if ident.eq_ignore_ascii_case("cluster") { - SyntaxKind::CLUSTER_KW - } else if ident.eq_ignore_ascii_case("coalesce") { - SyntaxKind::COALESCE_KW - } else if ident.eq_ignore_ascii_case("collate") { - SyntaxKind::COLLATE_KW - } else if ident.eq_ignore_ascii_case("collation") { - SyntaxKind::COLLATION_KW - } else if ident.eq_ignore_ascii_case("column") { - SyntaxKind::COLUMN_KW - } else if ident.eq_ignore_ascii_case("columns") { - SyntaxKind::COLUMNS_KW - } else if ident.eq_ignore_ascii_case("comment") { - SyntaxKind::COMMENT_KW - } else if ident.eq_ignore_ascii_case("comments") { - SyntaxKind::COMMENTS_KW - } else if ident.eq_ignore_ascii_case("commit") { - SyntaxKind::COMMIT_KW - } else if ident.eq_ignore_ascii_case("committed") { - SyntaxKind::COMMITTED_KW - } else if ident.eq_ignore_ascii_case("compression") { - SyntaxKind::COMPRESSION_KW - } else if ident.eq_ignore_ascii_case("concurrently") { - SyntaxKind::CONCURRENTLY_KW - } else if ident.eq_ignore_ascii_case("conditional") { - SyntaxKind::CONDITIONAL_KW - } else if ident.eq_ignore_ascii_case("configuration") { - SyntaxKind::CONFIGURATION_KW - } else if ident.eq_ignore_ascii_case("conflict") { - SyntaxKind::CONFLICT_KW - } else if ident.eq_ignore_ascii_case("connection") { - SyntaxKind::CONNECTION_KW - } else if ident.eq_ignore_ascii_case("constraint") { - SyntaxKind::CONSTRAINT_KW - } else if ident.eq_ignore_ascii_case("constraints") { - SyntaxKind::CONSTRAINTS_KW - } else if ident.eq_ignore_ascii_case("content") { - SyntaxKind::CONTENT_KW - } else if ident.eq_ignore_ascii_case("continue") { - SyntaxKind::CONTINUE_KW - } else if ident.eq_ignore_ascii_case("conversion") { - SyntaxKind::CONVERSION_KW - } else if ident.eq_ignore_ascii_case("copy") { - SyntaxKind::COPY_KW - } else if ident.eq_ignore_ascii_case("cost") { - SyntaxKind::COST_KW - } else if ident.eq_ignore_ascii_case("create") { - SyntaxKind::CREATE_KW - } else if ident.eq_ignore_ascii_case("cross") { - SyntaxKind::CROSS_KW - } else if ident.eq_ignore_ascii_case("csv") { - SyntaxKind::CSV_KW - } else if ident.eq_ignore_ascii_case("cube") { - SyntaxKind::CUBE_KW - } else if ident.eq_ignore_ascii_case("current") { - SyntaxKind::CURRENT_KW - } else if ident.eq_ignore_ascii_case("current_catalog") { - SyntaxKind::CURRENT_CATALOG_KW - } else if ident.eq_ignore_ascii_case("current_date") { - SyntaxKind::CURRENT_DATE_KW - } else if ident.eq_ignore_ascii_case("current_role") { - SyntaxKind::CURRENT_ROLE_KW - } else if ident.eq_ignore_ascii_case("current_schema") { - SyntaxKind::CURRENT_SCHEMA_KW - } else if ident.eq_ignore_ascii_case("current_time") { - SyntaxKind::CURRENT_TIME_KW - } else if ident.eq_ignore_ascii_case("current_timestamp") { - SyntaxKind::CURRENT_TIMESTAMP_KW - } else if ident.eq_ignore_ascii_case("current_user") { - SyntaxKind::CURRENT_USER_KW - } else if ident.eq_ignore_ascii_case("cursor") { - SyntaxKind::CURSOR_KW - } else if ident.eq_ignore_ascii_case("cycle") { - SyntaxKind::CYCLE_KW - } else if ident.eq_ignore_ascii_case("data") { - SyntaxKind::DATA_KW - } else if ident.eq_ignore_ascii_case("database") { - SyntaxKind::DATABASE_KW - } else if ident.eq_ignore_ascii_case("day") { - SyntaxKind::DAY_KW - } else if ident.eq_ignore_ascii_case("deallocate") { - SyntaxKind::DEALLOCATE_KW - } else if ident.eq_ignore_ascii_case("dec") { - SyntaxKind::DEC_KW - } else if ident.eq_ignore_ascii_case("decimal") { - SyntaxKind::DECIMAL_KW - } else if ident.eq_ignore_ascii_case("declare") { - SyntaxKind::DECLARE_KW - } else if ident.eq_ignore_ascii_case("default") { - SyntaxKind::DEFAULT_KW - } else if ident.eq_ignore_ascii_case("defaults") { - SyntaxKind::DEFAULTS_KW - } else if ident.eq_ignore_ascii_case("deferrable") { - SyntaxKind::DEFERRABLE_KW - } else if ident.eq_ignore_ascii_case("deferred") { - SyntaxKind::DEFERRED_KW - } else if ident.eq_ignore_ascii_case("definer") { - SyntaxKind::DEFINER_KW - } else if ident.eq_ignore_ascii_case("delete") { - SyntaxKind::DELETE_KW - } else if ident.eq_ignore_ascii_case("delimiter") { - SyntaxKind::DELIMITER_KW - } else if ident.eq_ignore_ascii_case("delimiters") { - SyntaxKind::DELIMITERS_KW - } else if ident.eq_ignore_ascii_case("depends") { - SyntaxKind::DEPENDS_KW - } else if ident.eq_ignore_ascii_case("depth") { - SyntaxKind::DEPTH_KW - } else if ident.eq_ignore_ascii_case("desc") { - SyntaxKind::DESC_KW - } else if ident.eq_ignore_ascii_case("detach") { - SyntaxKind::DETACH_KW - } else if ident.eq_ignore_ascii_case("dictionary") { - SyntaxKind::DICTIONARY_KW - } else if ident.eq_ignore_ascii_case("disable") { - SyntaxKind::DISABLE_KW - } else if ident.eq_ignore_ascii_case("discard") { - SyntaxKind::DISCARD_KW - } else if ident.eq_ignore_ascii_case("distinct") { - SyntaxKind::DISTINCT_KW - } else if ident.eq_ignore_ascii_case("do") { - SyntaxKind::DO_KW - } else if ident.eq_ignore_ascii_case("document") { - SyntaxKind::DOCUMENT_KW - } else if ident.eq_ignore_ascii_case("domain") { - SyntaxKind::DOMAIN_KW - } else if ident.eq_ignore_ascii_case("double") { - SyntaxKind::DOUBLE_KW - } else if ident.eq_ignore_ascii_case("drop") { - SyntaxKind::DROP_KW - } else if ident.eq_ignore_ascii_case("each") { - SyntaxKind::EACH_KW - } else if ident.eq_ignore_ascii_case("else") { - SyntaxKind::ELSE_KW - } else if ident.eq_ignore_ascii_case("empty") { - SyntaxKind::EMPTY_KW - } else if ident.eq_ignore_ascii_case("enable") { - SyntaxKind::ENABLE_KW - } else if ident.eq_ignore_ascii_case("encoding") { - SyntaxKind::ENCODING_KW - } else if ident.eq_ignore_ascii_case("encrypted") { - SyntaxKind::ENCRYPTED_KW - } else if ident.eq_ignore_ascii_case("end") { - SyntaxKind::END_KW - } else if ident.eq_ignore_ascii_case("enum") { - SyntaxKind::ENUM_KW - } else if ident.eq_ignore_ascii_case("error") { - SyntaxKind::ERROR_KW - } else if ident.eq_ignore_ascii_case("escape") { - SyntaxKind::ESCAPE_KW - } else if ident.eq_ignore_ascii_case("event") { - SyntaxKind::EVENT_KW - } else if ident.eq_ignore_ascii_case("except") { - SyntaxKind::EXCEPT_KW - } else if ident.eq_ignore_ascii_case("exclude") { - SyntaxKind::EXCLUDE_KW - } else if ident.eq_ignore_ascii_case("excluding") { - SyntaxKind::EXCLUDING_KW - } else if ident.eq_ignore_ascii_case("exclusive") { - SyntaxKind::EXCLUSIVE_KW - } else if ident.eq_ignore_ascii_case("execute") { - SyntaxKind::EXECUTE_KW - } else if ident.eq_ignore_ascii_case("exists") { - SyntaxKind::EXISTS_KW - } else if ident.eq_ignore_ascii_case("explain") { - SyntaxKind::EXPLAIN_KW - } else if ident.eq_ignore_ascii_case("expression") { - SyntaxKind::EXPRESSION_KW - } else if ident.eq_ignore_ascii_case("extension") { - SyntaxKind::EXTENSION_KW - } else if ident.eq_ignore_ascii_case("external") { - SyntaxKind::EXTERNAL_KW - } else if ident.eq_ignore_ascii_case("extract") { - SyntaxKind::EXTRACT_KW - } else if ident.eq_ignore_ascii_case("false") { - SyntaxKind::FALSE_KW - } else if ident.eq_ignore_ascii_case("family") { - SyntaxKind::FAMILY_KW - } else if ident.eq_ignore_ascii_case("fetch") { - SyntaxKind::FETCH_KW - } else if ident.eq_ignore_ascii_case("filter") { - SyntaxKind::FILTER_KW - } else if ident.eq_ignore_ascii_case("finalize") { - SyntaxKind::FINALIZE_KW - } else if ident.eq_ignore_ascii_case("first") { - SyntaxKind::FIRST_KW - } else if ident.eq_ignore_ascii_case("float") { - SyntaxKind::FLOAT_KW - } else if ident.eq_ignore_ascii_case("following") { - SyntaxKind::FOLLOWING_KW - } else if ident.eq_ignore_ascii_case("for") { - SyntaxKind::FOR_KW - } else if ident.eq_ignore_ascii_case("force") { - SyntaxKind::FORCE_KW - } else if ident.eq_ignore_ascii_case("foreign") { - SyntaxKind::FOREIGN_KW - } else if ident.eq_ignore_ascii_case("format") { - SyntaxKind::FORMAT_KW - } else if ident.eq_ignore_ascii_case("forward") { - SyntaxKind::FORWARD_KW - } else if ident.eq_ignore_ascii_case("freeze") { - SyntaxKind::FREEZE_KW - } else if ident.eq_ignore_ascii_case("from") { - SyntaxKind::FROM_KW - } else if ident.eq_ignore_ascii_case("full") { - SyntaxKind::FULL_KW - } else if ident.eq_ignore_ascii_case("function") { - SyntaxKind::FUNCTION_KW - } else if ident.eq_ignore_ascii_case("functions") { - SyntaxKind::FUNCTIONS_KW - } else if ident.eq_ignore_ascii_case("generated") { - SyntaxKind::GENERATED_KW - } else if ident.eq_ignore_ascii_case("global") { - SyntaxKind::GLOBAL_KW - } else if ident.eq_ignore_ascii_case("grant") { - SyntaxKind::GRANT_KW - } else if ident.eq_ignore_ascii_case("granted") { - SyntaxKind::GRANTED_KW - } else if ident.eq_ignore_ascii_case("greatest") { - SyntaxKind::GREATEST_KW - } else if ident.eq_ignore_ascii_case("group") { - SyntaxKind::GROUP_KW - } else if ident.eq_ignore_ascii_case("grouping") { - SyntaxKind::GROUPING_KW - } else if ident.eq_ignore_ascii_case("groups") { - SyntaxKind::GROUPS_KW - } else if ident.eq_ignore_ascii_case("handler") { - SyntaxKind::HANDLER_KW - } else if ident.eq_ignore_ascii_case("having") { - SyntaxKind::HAVING_KW - } else if ident.eq_ignore_ascii_case("header") { - SyntaxKind::HEADER_KW - } else if ident.eq_ignore_ascii_case("hold") { - SyntaxKind::HOLD_KW - } else if ident.eq_ignore_ascii_case("hour") { - SyntaxKind::HOUR_KW - } else if ident.eq_ignore_ascii_case("identity") { - SyntaxKind::IDENTITY_KW - } else if ident.eq_ignore_ascii_case("if") { - SyntaxKind::IF_KW - } else if ident.eq_ignore_ascii_case("ilike") { - SyntaxKind::ILIKE_KW - } else if ident.eq_ignore_ascii_case("immediate") { - SyntaxKind::IMMEDIATE_KW - } else if ident.eq_ignore_ascii_case("immutable") { - SyntaxKind::IMMUTABLE_KW - } else if ident.eq_ignore_ascii_case("implicit") { - SyntaxKind::IMPLICIT_KW - } else if ident.eq_ignore_ascii_case("import") { - SyntaxKind::IMPORT_KW - } else if ident.eq_ignore_ascii_case("in") { - SyntaxKind::IN_KW - } else if ident.eq_ignore_ascii_case("include") { - SyntaxKind::INCLUDE_KW - } else if ident.eq_ignore_ascii_case("including") { - SyntaxKind::INCLUDING_KW - } else if ident.eq_ignore_ascii_case("increment") { - SyntaxKind::INCREMENT_KW - } else if ident.eq_ignore_ascii_case("indent") { - SyntaxKind::INDENT_KW - } else if ident.eq_ignore_ascii_case("index") { - SyntaxKind::INDEX_KW - } else if ident.eq_ignore_ascii_case("indexes") { - SyntaxKind::INDEXES_KW - } else if ident.eq_ignore_ascii_case("inherit") { - SyntaxKind::INHERIT_KW - } else if ident.eq_ignore_ascii_case("inherits") { - SyntaxKind::INHERITS_KW - } else if ident.eq_ignore_ascii_case("initially") { - SyntaxKind::INITIALLY_KW - } else if ident.eq_ignore_ascii_case("inline") { - SyntaxKind::INLINE_KW - } else if ident.eq_ignore_ascii_case("inner") { - SyntaxKind::INNER_KW - } else if ident.eq_ignore_ascii_case("inout") { - SyntaxKind::INOUT_KW - } else if ident.eq_ignore_ascii_case("input") { - SyntaxKind::INPUT_KW - } else if ident.eq_ignore_ascii_case("insensitive") { - SyntaxKind::INSENSITIVE_KW - } else if ident.eq_ignore_ascii_case("insert") { - SyntaxKind::INSERT_KW - } else if ident.eq_ignore_ascii_case("instead") { - SyntaxKind::INSTEAD_KW - } else if ident.eq_ignore_ascii_case("int") { - SyntaxKind::INT_KW - } else if ident.eq_ignore_ascii_case("integer") { - SyntaxKind::INTEGER_KW - } else if ident.eq_ignore_ascii_case("intersect") { - SyntaxKind::INTERSECT_KW - } else if ident.eq_ignore_ascii_case("interval") { - SyntaxKind::INTERVAL_KW - } else if ident.eq_ignore_ascii_case("into") { - SyntaxKind::INTO_KW - } else if ident.eq_ignore_ascii_case("invoker") { - SyntaxKind::INVOKER_KW - } else if ident.eq_ignore_ascii_case("is") { - SyntaxKind::IS_KW - } else if ident.eq_ignore_ascii_case("isnull") { - SyntaxKind::ISNULL_KW - } else if ident.eq_ignore_ascii_case("isolation") { - SyntaxKind::ISOLATION_KW - } else if ident.eq_ignore_ascii_case("join") { - SyntaxKind::JOIN_KW - } else if ident.eq_ignore_ascii_case("json") { - SyntaxKind::JSON_KW - } else if ident.eq_ignore_ascii_case("json_array") { - SyntaxKind::JSON_ARRAY_KW - } else if ident.eq_ignore_ascii_case("json_arrayagg") { - SyntaxKind::JSON_ARRAYAGG_KW - } else if ident.eq_ignore_ascii_case("json_exists") { - SyntaxKind::JSON_EXISTS_KW - } else if ident.eq_ignore_ascii_case("json_object") { - SyntaxKind::JSON_OBJECT_KW - } else if ident.eq_ignore_ascii_case("json_objectagg") { - SyntaxKind::JSON_OBJECTAGG_KW - } else if ident.eq_ignore_ascii_case("json_query") { - SyntaxKind::JSON_QUERY_KW - } else if ident.eq_ignore_ascii_case("json_scalar") { - SyntaxKind::JSON_SCALAR_KW - } else if ident.eq_ignore_ascii_case("json_serialize") { - SyntaxKind::JSON_SERIALIZE_KW - } else if ident.eq_ignore_ascii_case("json_table") { - SyntaxKind::JSON_TABLE_KW - } else if ident.eq_ignore_ascii_case("json_value") { - SyntaxKind::JSON_VALUE_KW - } else if ident.eq_ignore_ascii_case("keep") { - SyntaxKind::KEEP_KW - } else if ident.eq_ignore_ascii_case("key") { - SyntaxKind::KEY_KW - } else if ident.eq_ignore_ascii_case("keys") { - SyntaxKind::KEYS_KW - } else if ident.eq_ignore_ascii_case("label") { - SyntaxKind::LABEL_KW - } else if ident.eq_ignore_ascii_case("language") { - SyntaxKind::LANGUAGE_KW - } else if ident.eq_ignore_ascii_case("large") { - SyntaxKind::LARGE_KW - } else if ident.eq_ignore_ascii_case("last") { - SyntaxKind::LAST_KW - } else if ident.eq_ignore_ascii_case("lateral") { - SyntaxKind::LATERAL_KW - } else if ident.eq_ignore_ascii_case("leading") { - SyntaxKind::LEADING_KW - } else if ident.eq_ignore_ascii_case("leakproof") { - SyntaxKind::LEAKPROOF_KW - } else if ident.eq_ignore_ascii_case("least") { - SyntaxKind::LEAST_KW - } else if ident.eq_ignore_ascii_case("left") { - SyntaxKind::LEFT_KW - } else if ident.eq_ignore_ascii_case("level") { - SyntaxKind::LEVEL_KW - } else if ident.eq_ignore_ascii_case("like") { - SyntaxKind::LIKE_KW - } else if ident.eq_ignore_ascii_case("limit") { - SyntaxKind::LIMIT_KW - } else if ident.eq_ignore_ascii_case("listen") { - SyntaxKind::LISTEN_KW - } else if ident.eq_ignore_ascii_case("load") { - SyntaxKind::LOAD_KW - } else if ident.eq_ignore_ascii_case("local") { - SyntaxKind::LOCAL_KW - } else if ident.eq_ignore_ascii_case("localtime") { - SyntaxKind::LOCALTIME_KW - } else if ident.eq_ignore_ascii_case("localtimestamp") { - SyntaxKind::LOCALTIMESTAMP_KW - } else if ident.eq_ignore_ascii_case("location") { - SyntaxKind::LOCATION_KW - } else if ident.eq_ignore_ascii_case("lock") { - SyntaxKind::LOCK_KW - } else if ident.eq_ignore_ascii_case("locked") { - SyntaxKind::LOCKED_KW - } else if ident.eq_ignore_ascii_case("logged") { - SyntaxKind::LOGGED_KW - } else if ident.eq_ignore_ascii_case("mapping") { - SyntaxKind::MAPPING_KW - } else if ident.eq_ignore_ascii_case("match") { - SyntaxKind::MATCH_KW - } else if ident.eq_ignore_ascii_case("matched") { - SyntaxKind::MATCHED_KW - } else if ident.eq_ignore_ascii_case("materialized") { - SyntaxKind::MATERIALIZED_KW - } else if ident.eq_ignore_ascii_case("maxvalue") { - SyntaxKind::MAXVALUE_KW - } else if ident.eq_ignore_ascii_case("merge") { - SyntaxKind::MERGE_KW - } else if ident.eq_ignore_ascii_case("merge_action") { - SyntaxKind::MERGE_ACTION_KW - } else if ident.eq_ignore_ascii_case("method") { - SyntaxKind::METHOD_KW - } else if ident.eq_ignore_ascii_case("minute") { - SyntaxKind::MINUTE_KW - } else if ident.eq_ignore_ascii_case("minvalue") { - SyntaxKind::MINVALUE_KW - } else if ident.eq_ignore_ascii_case("mode") { - SyntaxKind::MODE_KW - } else if ident.eq_ignore_ascii_case("month") { - SyntaxKind::MONTH_KW - } else if ident.eq_ignore_ascii_case("move") { - SyntaxKind::MOVE_KW - } else if ident.eq_ignore_ascii_case("name") { - SyntaxKind::NAME_KW - } else if ident.eq_ignore_ascii_case("names") { - SyntaxKind::NAMES_KW - } else if ident.eq_ignore_ascii_case("national") { - SyntaxKind::NATIONAL_KW - } else if ident.eq_ignore_ascii_case("natural") { - SyntaxKind::NATURAL_KW - } else if ident.eq_ignore_ascii_case("nchar") { - SyntaxKind::NCHAR_KW - } else if ident.eq_ignore_ascii_case("nested") { - SyntaxKind::NESTED_KW - } else if ident.eq_ignore_ascii_case("new") { - SyntaxKind::NEW_KW - } else if ident.eq_ignore_ascii_case("next") { - SyntaxKind::NEXT_KW - } else if ident.eq_ignore_ascii_case("nfc") { - SyntaxKind::NFC_KW - } else if ident.eq_ignore_ascii_case("nfd") { - SyntaxKind::NFD_KW - } else if ident.eq_ignore_ascii_case("nfkc") { - SyntaxKind::NFKC_KW - } else if ident.eq_ignore_ascii_case("nfkd") { - SyntaxKind::NFKD_KW - } else if ident.eq_ignore_ascii_case("no") { - SyntaxKind::NO_KW - } else if ident.eq_ignore_ascii_case("none") { - SyntaxKind::NONE_KW - } else if ident.eq_ignore_ascii_case("normalize") { - SyntaxKind::NORMALIZE_KW - } else if ident.eq_ignore_ascii_case("normalized") { - SyntaxKind::NORMALIZED_KW - } else if ident.eq_ignore_ascii_case("not") { - SyntaxKind::NOT_KW - } else if ident.eq_ignore_ascii_case("nothing") { - SyntaxKind::NOTHING_KW - } else if ident.eq_ignore_ascii_case("notify") { - SyntaxKind::NOTIFY_KW - } else if ident.eq_ignore_ascii_case("notnull") { - SyntaxKind::NOTNULL_KW - } else if ident.eq_ignore_ascii_case("nowait") { - SyntaxKind::NOWAIT_KW - } else if ident.eq_ignore_ascii_case("null") { - SyntaxKind::NULL_KW - } else if ident.eq_ignore_ascii_case("nullif") { - SyntaxKind::NULLIF_KW - } else if ident.eq_ignore_ascii_case("nulls") { - SyntaxKind::NULLS_KW - } else if ident.eq_ignore_ascii_case("numeric") { - SyntaxKind::NUMERIC_KW - } else if ident.eq_ignore_ascii_case("object") { - SyntaxKind::OBJECT_KW - } else if ident.eq_ignore_ascii_case("of") { - SyntaxKind::OF_KW - } else if ident.eq_ignore_ascii_case("off") { - SyntaxKind::OFF_KW - } else if ident.eq_ignore_ascii_case("offset") { - SyntaxKind::OFFSET_KW - } else if ident.eq_ignore_ascii_case("oids") { - SyntaxKind::OIDS_KW - } else if ident.eq_ignore_ascii_case("old") { - SyntaxKind::OLD_KW - } else if ident.eq_ignore_ascii_case("omit") { - SyntaxKind::OMIT_KW - } else if ident.eq_ignore_ascii_case("on") { - SyntaxKind::ON_KW - } else if ident.eq_ignore_ascii_case("only") { - SyntaxKind::ONLY_KW - } else if ident.eq_ignore_ascii_case("operator") { - SyntaxKind::OPERATOR_KW - } else if ident.eq_ignore_ascii_case("option") { - SyntaxKind::OPTION_KW - } else if ident.eq_ignore_ascii_case("options") { - SyntaxKind::OPTIONS_KW - } else if ident.eq_ignore_ascii_case("or") { - SyntaxKind::OR_KW - } else if ident.eq_ignore_ascii_case("order") { - SyntaxKind::ORDER_KW - } else if ident.eq_ignore_ascii_case("ordinality") { - SyntaxKind::ORDINALITY_KW - } else if ident.eq_ignore_ascii_case("others") { - SyntaxKind::OTHERS_KW - } else if ident.eq_ignore_ascii_case("out") { - SyntaxKind::OUT_KW - } else if ident.eq_ignore_ascii_case("outer") { - SyntaxKind::OUTER_KW - } else if ident.eq_ignore_ascii_case("over") { - SyntaxKind::OVER_KW - } else if ident.eq_ignore_ascii_case("overlaps") { - SyntaxKind::OVERLAPS_KW - } else if ident.eq_ignore_ascii_case("overlay") { - SyntaxKind::OVERLAY_KW - } else if ident.eq_ignore_ascii_case("overriding") { - SyntaxKind::OVERRIDING_KW - } else if ident.eq_ignore_ascii_case("owned") { - SyntaxKind::OWNED_KW - } else if ident.eq_ignore_ascii_case("owner") { - SyntaxKind::OWNER_KW - } else if ident.eq_ignore_ascii_case("parallel") { - SyntaxKind::PARALLEL_KW - } else if ident.eq_ignore_ascii_case("parameter") { - SyntaxKind::PARAMETER_KW - } else if ident.eq_ignore_ascii_case("parser") { - SyntaxKind::PARSER_KW - } else if ident.eq_ignore_ascii_case("partial") { - SyntaxKind::PARTIAL_KW - } else if ident.eq_ignore_ascii_case("partition") { - SyntaxKind::PARTITION_KW - } else if ident.eq_ignore_ascii_case("passing") { - SyntaxKind::PASSING_KW - } else if ident.eq_ignore_ascii_case("password") { - SyntaxKind::PASSWORD_KW - } else if ident.eq_ignore_ascii_case("path") { - SyntaxKind::PATH_KW - } else if ident.eq_ignore_ascii_case("period") { - SyntaxKind::PERIOD_KW - } else if ident.eq_ignore_ascii_case("placing") { - SyntaxKind::PLACING_KW - } else if ident.eq_ignore_ascii_case("plan") { - SyntaxKind::PLAN_KW - } else if ident.eq_ignore_ascii_case("plans") { - SyntaxKind::PLANS_KW - } else if ident.eq_ignore_ascii_case("policy") { - SyntaxKind::POLICY_KW - } else if ident.eq_ignore_ascii_case("position") { - SyntaxKind::POSITION_KW - } else if ident.eq_ignore_ascii_case("preceding") { - SyntaxKind::PRECEDING_KW - } else if ident.eq_ignore_ascii_case("precision") { - SyntaxKind::PRECISION_KW - } else if ident.eq_ignore_ascii_case("prepare") { - SyntaxKind::PREPARE_KW - } else if ident.eq_ignore_ascii_case("prepared") { - SyntaxKind::PREPARED_KW - } else if ident.eq_ignore_ascii_case("preserve") { - SyntaxKind::PRESERVE_KW - } else if ident.eq_ignore_ascii_case("primary") { - SyntaxKind::PRIMARY_KW - } else if ident.eq_ignore_ascii_case("prior") { - SyntaxKind::PRIOR_KW - } else if ident.eq_ignore_ascii_case("privileges") { - SyntaxKind::PRIVILEGES_KW - } else if ident.eq_ignore_ascii_case("procedural") { - SyntaxKind::PROCEDURAL_KW - } else if ident.eq_ignore_ascii_case("procedure") { - SyntaxKind::PROCEDURE_KW - } else if ident.eq_ignore_ascii_case("procedures") { - SyntaxKind::PROCEDURES_KW - } else if ident.eq_ignore_ascii_case("program") { - SyntaxKind::PROGRAM_KW - } else if ident.eq_ignore_ascii_case("publication") { - SyntaxKind::PUBLICATION_KW - } else if ident.eq_ignore_ascii_case("quote") { - SyntaxKind::QUOTE_KW - } else if ident.eq_ignore_ascii_case("quotes") { - SyntaxKind::QUOTES_KW - } else if ident.eq_ignore_ascii_case("range") { - SyntaxKind::RANGE_KW - } else if ident.eq_ignore_ascii_case("read") { - SyntaxKind::READ_KW - } else if ident.eq_ignore_ascii_case("real") { - SyntaxKind::REAL_KW - } else if ident.eq_ignore_ascii_case("reassign") { - SyntaxKind::REASSIGN_KW - } else if ident.eq_ignore_ascii_case("recursive") { - SyntaxKind::RECURSIVE_KW - } else if ident.eq_ignore_ascii_case("ref") { - SyntaxKind::REF_KW - } else if ident.eq_ignore_ascii_case("references") { - SyntaxKind::REFERENCES_KW - } else if ident.eq_ignore_ascii_case("referencing") { - SyntaxKind::REFERENCING_KW - } else if ident.eq_ignore_ascii_case("refresh") { - SyntaxKind::REFRESH_KW - } else if ident.eq_ignore_ascii_case("reindex") { - SyntaxKind::REINDEX_KW - } else if ident.eq_ignore_ascii_case("relative") { - SyntaxKind::RELATIVE_KW - } else if ident.eq_ignore_ascii_case("release") { - SyntaxKind::RELEASE_KW - } else if ident.eq_ignore_ascii_case("rename") { - SyntaxKind::RENAME_KW - } else if ident.eq_ignore_ascii_case("repeatable") { - SyntaxKind::REPEATABLE_KW - } else if ident.eq_ignore_ascii_case("replace") { - SyntaxKind::REPLACE_KW - } else if ident.eq_ignore_ascii_case("replica") { - SyntaxKind::REPLICA_KW - } else if ident.eq_ignore_ascii_case("reset") { - SyntaxKind::RESET_KW - } else if ident.eq_ignore_ascii_case("restart") { - SyntaxKind::RESTART_KW - } else if ident.eq_ignore_ascii_case("restrict") { - SyntaxKind::RESTRICT_KW - } else if ident.eq_ignore_ascii_case("return") { - SyntaxKind::RETURN_KW - } else if ident.eq_ignore_ascii_case("returning") { - SyntaxKind::RETURNING_KW - } else if ident.eq_ignore_ascii_case("returns") { - SyntaxKind::RETURNS_KW - } else if ident.eq_ignore_ascii_case("revoke") { - SyntaxKind::REVOKE_KW - } else if ident.eq_ignore_ascii_case("right") { - SyntaxKind::RIGHT_KW - } else if ident.eq_ignore_ascii_case("role") { - SyntaxKind::ROLE_KW - } else if ident.eq_ignore_ascii_case("rollback") { - SyntaxKind::ROLLBACK_KW - } else if ident.eq_ignore_ascii_case("rollup") { - SyntaxKind::ROLLUP_KW - } else if ident.eq_ignore_ascii_case("routine") { - SyntaxKind::ROUTINE_KW - } else if ident.eq_ignore_ascii_case("routines") { - SyntaxKind::ROUTINES_KW - } else if ident.eq_ignore_ascii_case("row") { - SyntaxKind::ROW_KW - } else if ident.eq_ignore_ascii_case("rows") { - SyntaxKind::ROWS_KW - } else if ident.eq_ignore_ascii_case("rule") { - SyntaxKind::RULE_KW - } else if ident.eq_ignore_ascii_case("savepoint") { - SyntaxKind::SAVEPOINT_KW - } else if ident.eq_ignore_ascii_case("scalar") { - SyntaxKind::SCALAR_KW - } else if ident.eq_ignore_ascii_case("schema") { - SyntaxKind::SCHEMA_KW - } else if ident.eq_ignore_ascii_case("schemas") { - SyntaxKind::SCHEMAS_KW - } else if ident.eq_ignore_ascii_case("scroll") { - SyntaxKind::SCROLL_KW - } else if ident.eq_ignore_ascii_case("search") { - SyntaxKind::SEARCH_KW - } else if ident.eq_ignore_ascii_case("second") { - SyntaxKind::SECOND_KW - } else if ident.eq_ignore_ascii_case("security") { - SyntaxKind::SECURITY_KW - } else if ident.eq_ignore_ascii_case("select") { - SyntaxKind::SELECT_KW - } else if ident.eq_ignore_ascii_case("sequence") { - SyntaxKind::SEQUENCE_KW - } else if ident.eq_ignore_ascii_case("sequences") { - SyntaxKind::SEQUENCES_KW - } else if ident.eq_ignore_ascii_case("serializable") { - SyntaxKind::SERIALIZABLE_KW - } else if ident.eq_ignore_ascii_case("server") { - SyntaxKind::SERVER_KW - } else if ident.eq_ignore_ascii_case("session") { - SyntaxKind::SESSION_KW - } else if ident.eq_ignore_ascii_case("session_user") { - SyntaxKind::SESSION_USER_KW - } else if ident.eq_ignore_ascii_case("set") { - SyntaxKind::SET_KW - } else if ident.eq_ignore_ascii_case("setof") { - SyntaxKind::SETOF_KW - } else if ident.eq_ignore_ascii_case("sets") { - SyntaxKind::SETS_KW - } else if ident.eq_ignore_ascii_case("share") { - SyntaxKind::SHARE_KW - } else if ident.eq_ignore_ascii_case("show") { - SyntaxKind::SHOW_KW - } else if ident.eq_ignore_ascii_case("similar") { - SyntaxKind::SIMILAR_KW - } else if ident.eq_ignore_ascii_case("simple") { - SyntaxKind::SIMPLE_KW - } else if ident.eq_ignore_ascii_case("skip") { - SyntaxKind::SKIP_KW - } else if ident.eq_ignore_ascii_case("smallint") { - SyntaxKind::SMALLINT_KW - } else if ident.eq_ignore_ascii_case("snapshot") { - SyntaxKind::SNAPSHOT_KW - } else if ident.eq_ignore_ascii_case("some") { - SyntaxKind::SOME_KW - } else if ident.eq_ignore_ascii_case("source") { - SyntaxKind::SOURCE_KW - } else if ident.eq_ignore_ascii_case("sql") { - SyntaxKind::SQL_KW - } else if ident.eq_ignore_ascii_case("stable") { - SyntaxKind::STABLE_KW - } else if ident.eq_ignore_ascii_case("standalone") { - SyntaxKind::STANDALONE_KW - } else if ident.eq_ignore_ascii_case("start") { - SyntaxKind::START_KW - } else if ident.eq_ignore_ascii_case("statement") { - SyntaxKind::STATEMENT_KW - } else if ident.eq_ignore_ascii_case("statistics") { - SyntaxKind::STATISTICS_KW - } else if ident.eq_ignore_ascii_case("stdin") { - SyntaxKind::STDIN_KW - } else if ident.eq_ignore_ascii_case("stdout") { - SyntaxKind::STDOUT_KW - } else if ident.eq_ignore_ascii_case("storage") { - SyntaxKind::STORAGE_KW - } else if ident.eq_ignore_ascii_case("stored") { - SyntaxKind::STORED_KW - } else if ident.eq_ignore_ascii_case("strict") { - SyntaxKind::STRICT_KW - } else if ident.eq_ignore_ascii_case("string") { - SyntaxKind::STRING_KW - } else if ident.eq_ignore_ascii_case("strip") { - SyntaxKind::STRIP_KW - } else if ident.eq_ignore_ascii_case("subscription") { - SyntaxKind::SUBSCRIPTION_KW - } else if ident.eq_ignore_ascii_case("substring") { - SyntaxKind::SUBSTRING_KW - } else if ident.eq_ignore_ascii_case("support") { - SyntaxKind::SUPPORT_KW - } else if ident.eq_ignore_ascii_case("symmetric") { - SyntaxKind::SYMMETRIC_KW - } else if ident.eq_ignore_ascii_case("sysid") { - SyntaxKind::SYSID_KW - } else if ident.eq_ignore_ascii_case("system") { - SyntaxKind::SYSTEM_KW - } else if ident.eq_ignore_ascii_case("system_user") { - SyntaxKind::SYSTEM_USER_KW - } else if ident.eq_ignore_ascii_case("table") { - SyntaxKind::TABLE_KW - } else if ident.eq_ignore_ascii_case("tables") { - SyntaxKind::TABLES_KW - } else if ident.eq_ignore_ascii_case("tablesample") { - SyntaxKind::TABLESAMPLE_KW - } else if ident.eq_ignore_ascii_case("tablespace") { - SyntaxKind::TABLESPACE_KW - } else if ident.eq_ignore_ascii_case("target") { - SyntaxKind::TARGET_KW - } else if ident.eq_ignore_ascii_case("temp") { - SyntaxKind::TEMP_KW - } else if ident.eq_ignore_ascii_case("template") { - SyntaxKind::TEMPLATE_KW - } else if ident.eq_ignore_ascii_case("temporary") { - SyntaxKind::TEMPORARY_KW - } else if ident.eq_ignore_ascii_case("text") { - SyntaxKind::TEXT_KW - } else if ident.eq_ignore_ascii_case("then") { - SyntaxKind::THEN_KW - } else if ident.eq_ignore_ascii_case("ties") { - SyntaxKind::TIES_KW - } else if ident.eq_ignore_ascii_case("time") { - SyntaxKind::TIME_KW - } else if ident.eq_ignore_ascii_case("timestamp") { - SyntaxKind::TIMESTAMP_KW - } else if ident.eq_ignore_ascii_case("to") { - SyntaxKind::TO_KW - } else if ident.eq_ignore_ascii_case("trailing") { - SyntaxKind::TRAILING_KW - } else if ident.eq_ignore_ascii_case("transaction") { - SyntaxKind::TRANSACTION_KW - } else if ident.eq_ignore_ascii_case("transform") { - SyntaxKind::TRANSFORM_KW - } else if ident.eq_ignore_ascii_case("treat") { - SyntaxKind::TREAT_KW - } else if ident.eq_ignore_ascii_case("trigger") { - SyntaxKind::TRIGGER_KW - } else if ident.eq_ignore_ascii_case("trim") { - SyntaxKind::TRIM_KW - } else if ident.eq_ignore_ascii_case("true") { - SyntaxKind::TRUE_KW - } else if ident.eq_ignore_ascii_case("truncate") { - SyntaxKind::TRUNCATE_KW - } else if ident.eq_ignore_ascii_case("trusted") { - SyntaxKind::TRUSTED_KW - } else if ident.eq_ignore_ascii_case("type") { - SyntaxKind::TYPE_KW - } else if ident.eq_ignore_ascii_case("types") { - SyntaxKind::TYPES_KW - } else if ident.eq_ignore_ascii_case("uescape") { - SyntaxKind::UESCAPE_KW - } else if ident.eq_ignore_ascii_case("unbounded") { - SyntaxKind::UNBOUNDED_KW - } else if ident.eq_ignore_ascii_case("uncommitted") { - SyntaxKind::UNCOMMITTED_KW - } else if ident.eq_ignore_ascii_case("unconditional") { - SyntaxKind::UNCONDITIONAL_KW - } else if ident.eq_ignore_ascii_case("unencrypted") { - SyntaxKind::UNENCRYPTED_KW - } else if ident.eq_ignore_ascii_case("union") { - SyntaxKind::UNION_KW - } else if ident.eq_ignore_ascii_case("unique") { - SyntaxKind::UNIQUE_KW - } else if ident.eq_ignore_ascii_case("unknown") { - SyntaxKind::UNKNOWN_KW - } else if ident.eq_ignore_ascii_case("unlisten") { - SyntaxKind::UNLISTEN_KW - } else if ident.eq_ignore_ascii_case("unlogged") { - SyntaxKind::UNLOGGED_KW - } else if ident.eq_ignore_ascii_case("until") { - SyntaxKind::UNTIL_KW - } else if ident.eq_ignore_ascii_case("update") { - SyntaxKind::UPDATE_KW - } else if ident.eq_ignore_ascii_case("user") { - SyntaxKind::USER_KW - } else if ident.eq_ignore_ascii_case("using") { - SyntaxKind::USING_KW - } else if ident.eq_ignore_ascii_case("vacuum") { - SyntaxKind::VACUUM_KW - } else if ident.eq_ignore_ascii_case("valid") { - SyntaxKind::VALID_KW - } else if ident.eq_ignore_ascii_case("validate") { - SyntaxKind::VALIDATE_KW - } else if ident.eq_ignore_ascii_case("validator") { - SyntaxKind::VALIDATOR_KW - } else if ident.eq_ignore_ascii_case("value") { - SyntaxKind::VALUE_KW - } else if ident.eq_ignore_ascii_case("values") { - SyntaxKind::VALUES_KW - } else if ident.eq_ignore_ascii_case("varchar") { - SyntaxKind::VARCHAR_KW - } else if ident.eq_ignore_ascii_case("variadic") { - SyntaxKind::VARIADIC_KW - } else if ident.eq_ignore_ascii_case("varying") { - SyntaxKind::VARYING_KW - } else if ident.eq_ignore_ascii_case("verbose") { - SyntaxKind::VERBOSE_KW - } else if ident.eq_ignore_ascii_case("version") { - SyntaxKind::VERSION_KW - } else if ident.eq_ignore_ascii_case("view") { - SyntaxKind::VIEW_KW - } else if ident.eq_ignore_ascii_case("views") { - SyntaxKind::VIEWS_KW - } else if ident.eq_ignore_ascii_case("volatile") { - SyntaxKind::VOLATILE_KW - } else if ident.eq_ignore_ascii_case("when") { - SyntaxKind::WHEN_KW - } else if ident.eq_ignore_ascii_case("where") { - SyntaxKind::WHERE_KW - } else if ident.eq_ignore_ascii_case("whitespace") { - SyntaxKind::WHITESPACE_KW - } else if ident.eq_ignore_ascii_case("window") { - SyntaxKind::WINDOW_KW - } else if ident.eq_ignore_ascii_case("with") { - SyntaxKind::WITH_KW - } else if ident.eq_ignore_ascii_case("within") { - SyntaxKind::WITHIN_KW - } else if ident.eq_ignore_ascii_case("without") { - SyntaxKind::WITHOUT_KW - } else if ident.eq_ignore_ascii_case("work") { - SyntaxKind::WORK_KW - } else if ident.eq_ignore_ascii_case("wrapper") { - SyntaxKind::WRAPPER_KW - } else if ident.eq_ignore_ascii_case("write") { - SyntaxKind::WRITE_KW - } else if ident.eq_ignore_ascii_case("xml") { - SyntaxKind::XML_KW - } else if ident.eq_ignore_ascii_case("xmlattributes") { - SyntaxKind::XMLATTRIBUTES_KW - } else if ident.eq_ignore_ascii_case("xmlconcat") { - SyntaxKind::XMLCONCAT_KW - } else if ident.eq_ignore_ascii_case("xmlelement") { - SyntaxKind::XMLELEMENT_KW - } else if ident.eq_ignore_ascii_case("xmlexists") { - SyntaxKind::XMLEXISTS_KW - } else if ident.eq_ignore_ascii_case("xmlforest") { - SyntaxKind::XMLFOREST_KW - } else if ident.eq_ignore_ascii_case("xmlnamespaces") { - SyntaxKind::XMLNAMESPACES_KW - } else if ident.eq_ignore_ascii_case("xmlparse") { - SyntaxKind::XMLPARSE_KW - } else if ident.eq_ignore_ascii_case("xmlpi") { - SyntaxKind::XMLPI_KW - } else if ident.eq_ignore_ascii_case("xmlroot") { - SyntaxKind::XMLROOT_KW - } else if ident.eq_ignore_ascii_case("xmlserialize") { - SyntaxKind::XMLSERIALIZE_KW - } else if ident.eq_ignore_ascii_case("xmltable") { - SyntaxKind::XMLTABLE_KW - } else if ident.eq_ignore_ascii_case("year") { - SyntaxKind::YEAR_KW - } else if ident.eq_ignore_ascii_case("yes") { - SyntaxKind::YES_KW - } else if ident.eq_ignore_ascii_case("zone") { - SyntaxKind::ZONE_KW - } else { - return None; - }; - Some(kw) - } } - -// Generated TokenSet start -pub(crate) const COLUMN_OR_TABLE_KEYWORDS: TokenSet = TokenSet::new(&[ - SyntaxKind::ABORT_KW, - SyntaxKind::ABSENT_KW, - SyntaxKind::ABSOLUTE_KW, - SyntaxKind::ACCESS_KW, - SyntaxKind::ACTION_KW, - SyntaxKind::ADD_KW, - SyntaxKind::ADMIN_KW, - SyntaxKind::AFTER_KW, - SyntaxKind::AGGREGATE_KW, - SyntaxKind::ALSO_KW, - SyntaxKind::ALTER_KW, - SyntaxKind::ALWAYS_KW, - SyntaxKind::ASENSITIVE_KW, - SyntaxKind::ASSERTION_KW, - SyntaxKind::ASSIGNMENT_KW, - SyntaxKind::AT_KW, - SyntaxKind::ATOMIC_KW, - SyntaxKind::ATTACH_KW, - SyntaxKind::ATTRIBUTE_KW, - SyntaxKind::BACKWARD_KW, - SyntaxKind::BEFORE_KW, - SyntaxKind::BEGIN_KW, - SyntaxKind::BETWEEN_KW, - SyntaxKind::BIGINT_KW, - SyntaxKind::BIT_KW, - SyntaxKind::BOOLEAN_KW, - SyntaxKind::BREADTH_KW, - SyntaxKind::BY_KW, - SyntaxKind::CACHE_KW, - SyntaxKind::CALL_KW, - SyntaxKind::CALLED_KW, - SyntaxKind::CASCADE_KW, - SyntaxKind::CASCADED_KW, - SyntaxKind::CATALOG_KW, - SyntaxKind::CHAIN_KW, - SyntaxKind::CHAR_KW, - SyntaxKind::CHARACTER_KW, - SyntaxKind::CHARACTERISTICS_KW, - SyntaxKind::CHECKPOINT_KW, - SyntaxKind::CLASS_KW, - SyntaxKind::CLOSE_KW, - SyntaxKind::CLUSTER_KW, - SyntaxKind::COALESCE_KW, - SyntaxKind::COLUMNS_KW, - SyntaxKind::COMMENT_KW, - SyntaxKind::COMMENTS_KW, - SyntaxKind::COMMIT_KW, - SyntaxKind::COMMITTED_KW, - SyntaxKind::COMPRESSION_KW, - SyntaxKind::CONDITIONAL_KW, - SyntaxKind::CONFIGURATION_KW, - SyntaxKind::CONFLICT_KW, - SyntaxKind::CONNECTION_KW, - SyntaxKind::CONSTRAINTS_KW, - SyntaxKind::CONTENT_KW, - SyntaxKind::CONTINUE_KW, - SyntaxKind::CONVERSION_KW, - SyntaxKind::COPY_KW, - SyntaxKind::COST_KW, - SyntaxKind::CSV_KW, - SyntaxKind::CUBE_KW, - SyntaxKind::CURRENT_KW, - SyntaxKind::CURSOR_KW, - SyntaxKind::CYCLE_KW, - SyntaxKind::DATA_KW, - SyntaxKind::DATABASE_KW, - SyntaxKind::DAY_KW, - SyntaxKind::DEALLOCATE_KW, - SyntaxKind::DEC_KW, - SyntaxKind::DECIMAL_KW, - SyntaxKind::DECLARE_KW, - SyntaxKind::DEFAULTS_KW, - SyntaxKind::DEFERRED_KW, - SyntaxKind::DEFINER_KW, - SyntaxKind::DELETE_KW, - SyntaxKind::DELIMITER_KW, - SyntaxKind::DELIMITERS_KW, - SyntaxKind::DEPENDS_KW, - SyntaxKind::DEPTH_KW, - SyntaxKind::DETACH_KW, - SyntaxKind::DICTIONARY_KW, - SyntaxKind::DISABLE_KW, - SyntaxKind::DISCARD_KW, - SyntaxKind::DOCUMENT_KW, - SyntaxKind::DOMAIN_KW, - SyntaxKind::DOUBLE_KW, - SyntaxKind::DROP_KW, - SyntaxKind::EACH_KW, - SyntaxKind::EMPTY_KW, - SyntaxKind::ENABLE_KW, - SyntaxKind::ENCODING_KW, - SyntaxKind::ENCRYPTED_KW, - SyntaxKind::ENUM_KW, - SyntaxKind::ERROR_KW, - SyntaxKind::ESCAPE_KW, - SyntaxKind::EVENT_KW, - SyntaxKind::EXCLUDE_KW, - SyntaxKind::EXCLUDING_KW, - SyntaxKind::EXCLUSIVE_KW, - SyntaxKind::EXECUTE_KW, - SyntaxKind::EXISTS_KW, - SyntaxKind::EXPLAIN_KW, - SyntaxKind::EXPRESSION_KW, - SyntaxKind::EXTENSION_KW, - SyntaxKind::EXTERNAL_KW, - SyntaxKind::EXTRACT_KW, - SyntaxKind::FAMILY_KW, - SyntaxKind::FILTER_KW, - SyntaxKind::FINALIZE_KW, - SyntaxKind::FIRST_KW, - SyntaxKind::FLOAT_KW, - SyntaxKind::FOLLOWING_KW, - SyntaxKind::FORCE_KW, - SyntaxKind::FORMAT_KW, - SyntaxKind::FORWARD_KW, - SyntaxKind::FUNCTION_KW, - SyntaxKind::FUNCTIONS_KW, - SyntaxKind::GENERATED_KW, - SyntaxKind::GLOBAL_KW, - SyntaxKind::GRANTED_KW, - SyntaxKind::GREATEST_KW, - SyntaxKind::GROUPING_KW, - SyntaxKind::GROUPS_KW, - SyntaxKind::HANDLER_KW, - SyntaxKind::HEADER_KW, - SyntaxKind::HOLD_KW, - SyntaxKind::HOUR_KW, - SyntaxKind::IDENTITY_KW, - SyntaxKind::IF_KW, - SyntaxKind::IMMEDIATE_KW, - SyntaxKind::IMMUTABLE_KW, - SyntaxKind::IMPLICIT_KW, - SyntaxKind::IMPORT_KW, - SyntaxKind::INCLUDE_KW, - SyntaxKind::INCLUDING_KW, - SyntaxKind::INCREMENT_KW, - SyntaxKind::INDENT_KW, - SyntaxKind::INDEX_KW, - SyntaxKind::INDEXES_KW, - SyntaxKind::INHERIT_KW, - SyntaxKind::INHERITS_KW, - SyntaxKind::INLINE_KW, - SyntaxKind::INOUT_KW, - SyntaxKind::INPUT_KW, - SyntaxKind::INSENSITIVE_KW, - SyntaxKind::INSERT_KW, - SyntaxKind::INSTEAD_KW, - SyntaxKind::INT_KW, - SyntaxKind::INTEGER_KW, - SyntaxKind::INTERVAL_KW, - SyntaxKind::INVOKER_KW, - SyntaxKind::ISOLATION_KW, - SyntaxKind::JSON_KW, - SyntaxKind::JSON_ARRAY_KW, - SyntaxKind::JSON_ARRAYAGG_KW, - SyntaxKind::JSON_EXISTS_KW, - SyntaxKind::JSON_OBJECT_KW, - SyntaxKind::JSON_OBJECTAGG_KW, - SyntaxKind::JSON_QUERY_KW, - SyntaxKind::JSON_SCALAR_KW, - SyntaxKind::JSON_SERIALIZE_KW, - SyntaxKind::JSON_TABLE_KW, - SyntaxKind::JSON_VALUE_KW, - SyntaxKind::KEEP_KW, - SyntaxKind::KEY_KW, - SyntaxKind::KEYS_KW, - SyntaxKind::LABEL_KW, - SyntaxKind::LANGUAGE_KW, - SyntaxKind::LARGE_KW, - SyntaxKind::LAST_KW, - SyntaxKind::LEAKPROOF_KW, - SyntaxKind::LEAST_KW, - SyntaxKind::LEVEL_KW, - SyntaxKind::LISTEN_KW, - SyntaxKind::LOAD_KW, - SyntaxKind::LOCAL_KW, - SyntaxKind::LOCATION_KW, - SyntaxKind::LOCK_KW, - SyntaxKind::LOCKED_KW, - SyntaxKind::LOGGED_KW, - SyntaxKind::MAPPING_KW, - SyntaxKind::MATCH_KW, - SyntaxKind::MATCHED_KW, - SyntaxKind::MATERIALIZED_KW, - SyntaxKind::MAXVALUE_KW, - SyntaxKind::MERGE_KW, - SyntaxKind::MERGE_ACTION_KW, - SyntaxKind::METHOD_KW, - SyntaxKind::MINUTE_KW, - SyntaxKind::MINVALUE_KW, - SyntaxKind::MODE_KW, - SyntaxKind::MONTH_KW, - SyntaxKind::MOVE_KW, - SyntaxKind::NAME_KW, - SyntaxKind::NAMES_KW, - SyntaxKind::NATIONAL_KW, - SyntaxKind::NCHAR_KW, - SyntaxKind::NESTED_KW, - SyntaxKind::NEW_KW, - SyntaxKind::NEXT_KW, - SyntaxKind::NFC_KW, - SyntaxKind::NFD_KW, - SyntaxKind::NFKC_KW, - SyntaxKind::NFKD_KW, - SyntaxKind::NO_KW, - SyntaxKind::NONE_KW, - SyntaxKind::NORMALIZE_KW, - SyntaxKind::NORMALIZED_KW, - SyntaxKind::NOTHING_KW, - SyntaxKind::NOTIFY_KW, - SyntaxKind::NOWAIT_KW, - SyntaxKind::NULLIF_KW, - SyntaxKind::NULLS_KW, - SyntaxKind::NUMERIC_KW, - SyntaxKind::OBJECT_KW, - SyntaxKind::OF_KW, - SyntaxKind::OFF_KW, - SyntaxKind::OIDS_KW, - SyntaxKind::OLD_KW, - SyntaxKind::OMIT_KW, - SyntaxKind::OPERATOR_KW, - SyntaxKind::OPTION_KW, - SyntaxKind::OPTIONS_KW, - SyntaxKind::ORDINALITY_KW, - SyntaxKind::OTHERS_KW, - SyntaxKind::OUT_KW, - SyntaxKind::OVER_KW, - SyntaxKind::OVERLAY_KW, - SyntaxKind::OVERRIDING_KW, - SyntaxKind::OWNED_KW, - SyntaxKind::OWNER_KW, - SyntaxKind::PARALLEL_KW, - SyntaxKind::PARAMETER_KW, - SyntaxKind::PARSER_KW, - SyntaxKind::PARTIAL_KW, - SyntaxKind::PARTITION_KW, - SyntaxKind::PASSING_KW, - SyntaxKind::PASSWORD_KW, - SyntaxKind::PATH_KW, - SyntaxKind::PERIOD_KW, - SyntaxKind::PLAN_KW, - SyntaxKind::PLANS_KW, - SyntaxKind::POLICY_KW, - SyntaxKind::POSITION_KW, - SyntaxKind::PRECEDING_KW, - SyntaxKind::PRECISION_KW, - SyntaxKind::PREPARE_KW, - SyntaxKind::PREPARED_KW, - SyntaxKind::PRESERVE_KW, - SyntaxKind::PRIOR_KW, - SyntaxKind::PRIVILEGES_KW, - SyntaxKind::PROCEDURAL_KW, - SyntaxKind::PROCEDURE_KW, - SyntaxKind::PROCEDURES_KW, - SyntaxKind::PROGRAM_KW, - SyntaxKind::PUBLICATION_KW, - SyntaxKind::QUOTE_KW, - SyntaxKind::QUOTES_KW, - SyntaxKind::RANGE_KW, - SyntaxKind::READ_KW, - SyntaxKind::REAL_KW, - SyntaxKind::REASSIGN_KW, - SyntaxKind::RECURSIVE_KW, - SyntaxKind::REF_KW, - SyntaxKind::REFERENCING_KW, - SyntaxKind::REFRESH_KW, - SyntaxKind::REINDEX_KW, - SyntaxKind::RELATIVE_KW, - SyntaxKind::RELEASE_KW, - SyntaxKind::RENAME_KW, - SyntaxKind::REPEATABLE_KW, - SyntaxKind::REPLACE_KW, - SyntaxKind::REPLICA_KW, - SyntaxKind::RESET_KW, - SyntaxKind::RESTART_KW, - SyntaxKind::RESTRICT_KW, - SyntaxKind::RETURN_KW, - SyntaxKind::RETURNS_KW, - SyntaxKind::REVOKE_KW, - SyntaxKind::ROLE_KW, - SyntaxKind::ROLLBACK_KW, - SyntaxKind::ROLLUP_KW, - SyntaxKind::ROUTINE_KW, - SyntaxKind::ROUTINES_KW, - SyntaxKind::ROW_KW, - SyntaxKind::ROWS_KW, - SyntaxKind::RULE_KW, - SyntaxKind::SAVEPOINT_KW, - SyntaxKind::SCALAR_KW, - SyntaxKind::SCHEMA_KW, - SyntaxKind::SCHEMAS_KW, - SyntaxKind::SCROLL_KW, - SyntaxKind::SEARCH_KW, - SyntaxKind::SECOND_KW, - SyntaxKind::SECURITY_KW, - SyntaxKind::SEQUENCE_KW, - SyntaxKind::SEQUENCES_KW, - SyntaxKind::SERIALIZABLE_KW, - SyntaxKind::SERVER_KW, - SyntaxKind::SESSION_KW, - SyntaxKind::SET_KW, - SyntaxKind::SETOF_KW, - SyntaxKind::SETS_KW, - SyntaxKind::SHARE_KW, - SyntaxKind::SHOW_KW, - SyntaxKind::SIMPLE_KW, - SyntaxKind::SKIP_KW, - SyntaxKind::SMALLINT_KW, - SyntaxKind::SNAPSHOT_KW, - SyntaxKind::SOURCE_KW, - SyntaxKind::SQL_KW, - SyntaxKind::STABLE_KW, - SyntaxKind::STANDALONE_KW, - SyntaxKind::START_KW, - SyntaxKind::STATEMENT_KW, - SyntaxKind::STATISTICS_KW, - SyntaxKind::STDIN_KW, - SyntaxKind::STDOUT_KW, - SyntaxKind::STORAGE_KW, - SyntaxKind::STORED_KW, - SyntaxKind::STRICT_KW, - SyntaxKind::STRING_KW, - SyntaxKind::STRIP_KW, - SyntaxKind::SUBSCRIPTION_KW, - SyntaxKind::SUBSTRING_KW, - SyntaxKind::SUPPORT_KW, - SyntaxKind::SYSID_KW, - SyntaxKind::SYSTEM_KW, - SyntaxKind::TABLES_KW, - SyntaxKind::TABLESPACE_KW, - SyntaxKind::TARGET_KW, - SyntaxKind::TEMP_KW, - SyntaxKind::TEMPLATE_KW, - SyntaxKind::TEMPORARY_KW, - SyntaxKind::TEXT_KW, - SyntaxKind::TIES_KW, - SyntaxKind::TIME_KW, - SyntaxKind::TIMESTAMP_KW, - SyntaxKind::TRANSACTION_KW, - SyntaxKind::TRANSFORM_KW, - SyntaxKind::TREAT_KW, - SyntaxKind::TRIGGER_KW, - SyntaxKind::TRIM_KW, - SyntaxKind::TRUNCATE_KW, - SyntaxKind::TRUSTED_KW, - SyntaxKind::TYPE_KW, - SyntaxKind::TYPES_KW, - SyntaxKind::UESCAPE_KW, - SyntaxKind::UNBOUNDED_KW, - SyntaxKind::UNCOMMITTED_KW, - SyntaxKind::UNCONDITIONAL_KW, - SyntaxKind::UNENCRYPTED_KW, - SyntaxKind::UNKNOWN_KW, - SyntaxKind::UNLISTEN_KW, - SyntaxKind::UNLOGGED_KW, - SyntaxKind::UNTIL_KW, - SyntaxKind::UPDATE_KW, - SyntaxKind::VACUUM_KW, - SyntaxKind::VALID_KW, - SyntaxKind::VALIDATE_KW, - SyntaxKind::VALIDATOR_KW, - SyntaxKind::VALUE_KW, - SyntaxKind::VALUES_KW, - SyntaxKind::VARCHAR_KW, - SyntaxKind::VARYING_KW, - SyntaxKind::VERSION_KW, - SyntaxKind::VIEW_KW, - SyntaxKind::VIEWS_KW, - SyntaxKind::VOLATILE_KW, - SyntaxKind::WHITESPACE_KW, - SyntaxKind::WITHIN_KW, - SyntaxKind::WITHOUT_KW, - SyntaxKind::WORK_KW, - SyntaxKind::WRAPPER_KW, - SyntaxKind::WRITE_KW, - SyntaxKind::XML_KW, - SyntaxKind::XMLATTRIBUTES_KW, - SyntaxKind::XMLCONCAT_KW, - SyntaxKind::XMLELEMENT_KW, - SyntaxKind::XMLEXISTS_KW, - SyntaxKind::XMLFOREST_KW, - SyntaxKind::XMLNAMESPACES_KW, - SyntaxKind::XMLPARSE_KW, - SyntaxKind::XMLPI_KW, - SyntaxKind::XMLROOT_KW, - SyntaxKind::XMLSERIALIZE_KW, - SyntaxKind::XMLTABLE_KW, - SyntaxKind::YEAR_KW, - SyntaxKind::YES_KW, - SyntaxKind::ZONE_KW, -]); - -pub(crate) const TYPE_KEYWORDS: TokenSet = TokenSet::new(&[ - SyntaxKind::ABORT_KW, - SyntaxKind::ABSENT_KW, - SyntaxKind::ABSOLUTE_KW, - SyntaxKind::ACCESS_KW, - SyntaxKind::ACTION_KW, - SyntaxKind::ADD_KW, - SyntaxKind::ADMIN_KW, - SyntaxKind::AFTER_KW, - SyntaxKind::AGGREGATE_KW, - SyntaxKind::ALSO_KW, - SyntaxKind::ALTER_KW, - SyntaxKind::ALWAYS_KW, - SyntaxKind::ASENSITIVE_KW, - SyntaxKind::ASSERTION_KW, - SyntaxKind::ASSIGNMENT_KW, - SyntaxKind::AT_KW, - SyntaxKind::ATOMIC_KW, - SyntaxKind::ATTACH_KW, - SyntaxKind::ATTRIBUTE_KW, - SyntaxKind::AUTHORIZATION_KW, - SyntaxKind::BACKWARD_KW, - SyntaxKind::BEFORE_KW, - SyntaxKind::BEGIN_KW, - SyntaxKind::BETWEEN_KW, - SyntaxKind::BIGINT_KW, - SyntaxKind::BINARY_KW, - SyntaxKind::BIT_KW, - SyntaxKind::BOOLEAN_KW, - SyntaxKind::BREADTH_KW, - SyntaxKind::BY_KW, - SyntaxKind::CACHE_KW, - SyntaxKind::CALL_KW, - SyntaxKind::CALLED_KW, - SyntaxKind::CASCADE_KW, - SyntaxKind::CASCADED_KW, - SyntaxKind::CATALOG_KW, - SyntaxKind::CHAIN_KW, - SyntaxKind::CHAR_KW, - SyntaxKind::CHARACTER_KW, - SyntaxKind::CHARACTERISTICS_KW, - SyntaxKind::CHECKPOINT_KW, - SyntaxKind::CLASS_KW, - SyntaxKind::CLOSE_KW, - SyntaxKind::CLUSTER_KW, - SyntaxKind::COALESCE_KW, - SyntaxKind::COLLATION_KW, - SyntaxKind::COLUMNS_KW, - SyntaxKind::COMMENT_KW, - SyntaxKind::COMMENTS_KW, - SyntaxKind::COMMIT_KW, - SyntaxKind::COMMITTED_KW, - SyntaxKind::COMPRESSION_KW, - SyntaxKind::CONCURRENTLY_KW, - SyntaxKind::CONDITIONAL_KW, - SyntaxKind::CONFIGURATION_KW, - SyntaxKind::CONFLICT_KW, - SyntaxKind::CONNECTION_KW, - SyntaxKind::CONSTRAINTS_KW, - SyntaxKind::CONTENT_KW, - SyntaxKind::CONTINUE_KW, - SyntaxKind::CONVERSION_KW, - SyntaxKind::COPY_KW, - SyntaxKind::COST_KW, - SyntaxKind::CROSS_KW, - SyntaxKind::CSV_KW, - SyntaxKind::CUBE_KW, - SyntaxKind::CURRENT_KW, - SyntaxKind::CURRENT_SCHEMA_KW, - SyntaxKind::CURSOR_KW, - SyntaxKind::CYCLE_KW, - SyntaxKind::DATA_KW, - SyntaxKind::DATABASE_KW, - SyntaxKind::DAY_KW, - SyntaxKind::DEALLOCATE_KW, - SyntaxKind::DEC_KW, - SyntaxKind::DECIMAL_KW, - SyntaxKind::DECLARE_KW, - SyntaxKind::DEFAULTS_KW, - SyntaxKind::DEFERRED_KW, - SyntaxKind::DEFINER_KW, - SyntaxKind::DELETE_KW, - SyntaxKind::DELIMITER_KW, - SyntaxKind::DELIMITERS_KW, - SyntaxKind::DEPENDS_KW, - SyntaxKind::DEPTH_KW, - SyntaxKind::DETACH_KW, - SyntaxKind::DICTIONARY_KW, - SyntaxKind::DISABLE_KW, - SyntaxKind::DISCARD_KW, - SyntaxKind::DOCUMENT_KW, - SyntaxKind::DOMAIN_KW, - SyntaxKind::DOUBLE_KW, - SyntaxKind::DROP_KW, - SyntaxKind::EACH_KW, - SyntaxKind::EMPTY_KW, - SyntaxKind::ENABLE_KW, - SyntaxKind::ENCODING_KW, - SyntaxKind::ENCRYPTED_KW, - SyntaxKind::ENUM_KW, - SyntaxKind::ERROR_KW, - SyntaxKind::ESCAPE_KW, - SyntaxKind::EVENT_KW, - SyntaxKind::EXCLUDE_KW, - SyntaxKind::EXCLUDING_KW, - SyntaxKind::EXCLUSIVE_KW, - SyntaxKind::EXECUTE_KW, - SyntaxKind::EXISTS_KW, - SyntaxKind::EXPLAIN_KW, - SyntaxKind::EXPRESSION_KW, - SyntaxKind::EXTENSION_KW, - SyntaxKind::EXTERNAL_KW, - SyntaxKind::EXTRACT_KW, - SyntaxKind::FAMILY_KW, - SyntaxKind::FILTER_KW, - SyntaxKind::FINALIZE_KW, - SyntaxKind::FIRST_KW, - SyntaxKind::FLOAT_KW, - SyntaxKind::FOLLOWING_KW, - SyntaxKind::FORCE_KW, - SyntaxKind::FORMAT_KW, - SyntaxKind::FORWARD_KW, - SyntaxKind::FREEZE_KW, - SyntaxKind::FULL_KW, - SyntaxKind::FUNCTION_KW, - SyntaxKind::FUNCTIONS_KW, - SyntaxKind::GENERATED_KW, - SyntaxKind::GLOBAL_KW, - SyntaxKind::GRANTED_KW, - SyntaxKind::GREATEST_KW, - SyntaxKind::GROUPING_KW, - SyntaxKind::GROUPS_KW, - SyntaxKind::HANDLER_KW, - SyntaxKind::HEADER_KW, - SyntaxKind::HOLD_KW, - SyntaxKind::HOUR_KW, - SyntaxKind::IDENTITY_KW, - SyntaxKind::IF_KW, - SyntaxKind::ILIKE_KW, - SyntaxKind::IMMEDIATE_KW, - SyntaxKind::IMMUTABLE_KW, - SyntaxKind::IMPLICIT_KW, - SyntaxKind::IMPORT_KW, - SyntaxKind::INCLUDE_KW, - SyntaxKind::INCLUDING_KW, - SyntaxKind::INCREMENT_KW, - SyntaxKind::INDENT_KW, - SyntaxKind::INDEX_KW, - SyntaxKind::INDEXES_KW, - SyntaxKind::INHERIT_KW, - SyntaxKind::INHERITS_KW, - SyntaxKind::INLINE_KW, - SyntaxKind::INNER_KW, - SyntaxKind::INOUT_KW, - SyntaxKind::INPUT_KW, - SyntaxKind::INSENSITIVE_KW, - SyntaxKind::INSERT_KW, - SyntaxKind::INSTEAD_KW, - SyntaxKind::INT_KW, - SyntaxKind::INTEGER_KW, - SyntaxKind::INTERVAL_KW, - SyntaxKind::INVOKER_KW, - SyntaxKind::IS_KW, - SyntaxKind::ISNULL_KW, - SyntaxKind::ISOLATION_KW, - SyntaxKind::JOIN_KW, - SyntaxKind::JSON_KW, - SyntaxKind::JSON_ARRAY_KW, - SyntaxKind::JSON_ARRAYAGG_KW, - SyntaxKind::JSON_EXISTS_KW, - SyntaxKind::JSON_OBJECT_KW, - SyntaxKind::JSON_OBJECTAGG_KW, - SyntaxKind::JSON_QUERY_KW, - SyntaxKind::JSON_SCALAR_KW, - SyntaxKind::JSON_SERIALIZE_KW, - SyntaxKind::JSON_TABLE_KW, - SyntaxKind::JSON_VALUE_KW, - SyntaxKind::KEEP_KW, - SyntaxKind::KEY_KW, - SyntaxKind::KEYS_KW, - SyntaxKind::LABEL_KW, - SyntaxKind::LANGUAGE_KW, - SyntaxKind::LARGE_KW, - SyntaxKind::LAST_KW, - SyntaxKind::LEAKPROOF_KW, - SyntaxKind::LEAST_KW, - SyntaxKind::LEFT_KW, - SyntaxKind::LEVEL_KW, - SyntaxKind::LIKE_KW, - SyntaxKind::LISTEN_KW, - SyntaxKind::LOAD_KW, - SyntaxKind::LOCAL_KW, - SyntaxKind::LOCATION_KW, - SyntaxKind::LOCK_KW, - SyntaxKind::LOCKED_KW, - SyntaxKind::LOGGED_KW, - SyntaxKind::MAPPING_KW, - SyntaxKind::MATCH_KW, - SyntaxKind::MATCHED_KW, - SyntaxKind::MATERIALIZED_KW, - SyntaxKind::MAXVALUE_KW, - SyntaxKind::MERGE_KW, - SyntaxKind::MERGE_ACTION_KW, - SyntaxKind::METHOD_KW, - SyntaxKind::MINUTE_KW, - SyntaxKind::MINVALUE_KW, - SyntaxKind::MODE_KW, - SyntaxKind::MONTH_KW, - SyntaxKind::MOVE_KW, - SyntaxKind::NAME_KW, - SyntaxKind::NAMES_KW, - SyntaxKind::NATIONAL_KW, - SyntaxKind::NATURAL_KW, - SyntaxKind::NCHAR_KW, - SyntaxKind::NESTED_KW, - SyntaxKind::NEW_KW, - SyntaxKind::NEXT_KW, - SyntaxKind::NFC_KW, - SyntaxKind::NFD_KW, - SyntaxKind::NFKC_KW, - SyntaxKind::NFKD_KW, - SyntaxKind::NO_KW, - SyntaxKind::NONE_KW, - SyntaxKind::NORMALIZE_KW, - SyntaxKind::NORMALIZED_KW, - SyntaxKind::NOTHING_KW, - SyntaxKind::NOTIFY_KW, - SyntaxKind::NOTNULL_KW, - SyntaxKind::NOWAIT_KW, - SyntaxKind::NULLIF_KW, - SyntaxKind::NULLS_KW, - SyntaxKind::NUMERIC_KW, - SyntaxKind::OBJECT_KW, - SyntaxKind::OF_KW, - SyntaxKind::OFF_KW, - SyntaxKind::OIDS_KW, - SyntaxKind::OLD_KW, - SyntaxKind::OMIT_KW, - SyntaxKind::OPERATOR_KW, - SyntaxKind::OPTION_KW, - SyntaxKind::OPTIONS_KW, - SyntaxKind::ORDINALITY_KW, - SyntaxKind::OTHERS_KW, - SyntaxKind::OUT_KW, - SyntaxKind::OUTER_KW, - SyntaxKind::OVER_KW, - SyntaxKind::OVERLAPS_KW, - SyntaxKind::OVERLAY_KW, - SyntaxKind::OVERRIDING_KW, - SyntaxKind::OWNED_KW, - SyntaxKind::OWNER_KW, - SyntaxKind::PARALLEL_KW, - SyntaxKind::PARAMETER_KW, - SyntaxKind::PARSER_KW, - SyntaxKind::PARTIAL_KW, - SyntaxKind::PARTITION_KW, - SyntaxKind::PASSING_KW, - SyntaxKind::PASSWORD_KW, - SyntaxKind::PATH_KW, - SyntaxKind::PERIOD_KW, - SyntaxKind::PLAN_KW, - SyntaxKind::PLANS_KW, - SyntaxKind::POLICY_KW, - SyntaxKind::POSITION_KW, - SyntaxKind::PRECEDING_KW, - SyntaxKind::PRECISION_KW, - SyntaxKind::PREPARE_KW, - SyntaxKind::PREPARED_KW, - SyntaxKind::PRESERVE_KW, - SyntaxKind::PRIOR_KW, - SyntaxKind::PRIVILEGES_KW, - SyntaxKind::PROCEDURAL_KW, - SyntaxKind::PROCEDURE_KW, - SyntaxKind::PROCEDURES_KW, - SyntaxKind::PROGRAM_KW, - SyntaxKind::PUBLICATION_KW, - SyntaxKind::QUOTE_KW, - SyntaxKind::QUOTES_KW, - SyntaxKind::RANGE_KW, - SyntaxKind::READ_KW, - SyntaxKind::REAL_KW, - SyntaxKind::REASSIGN_KW, - SyntaxKind::RECURSIVE_KW, - SyntaxKind::REF_KW, - SyntaxKind::REFERENCING_KW, - SyntaxKind::REFRESH_KW, - SyntaxKind::REINDEX_KW, - SyntaxKind::RELATIVE_KW, - SyntaxKind::RELEASE_KW, - SyntaxKind::RENAME_KW, - SyntaxKind::REPEATABLE_KW, - SyntaxKind::REPLACE_KW, - SyntaxKind::REPLICA_KW, - SyntaxKind::RESET_KW, - SyntaxKind::RESTART_KW, - SyntaxKind::RESTRICT_KW, - SyntaxKind::RETURN_KW, - SyntaxKind::RETURNS_KW, - SyntaxKind::REVOKE_KW, - SyntaxKind::RIGHT_KW, - SyntaxKind::ROLE_KW, - SyntaxKind::ROLLBACK_KW, - SyntaxKind::ROLLUP_KW, - SyntaxKind::ROUTINE_KW, - SyntaxKind::ROUTINES_KW, - SyntaxKind::ROW_KW, - SyntaxKind::ROWS_KW, - SyntaxKind::RULE_KW, - SyntaxKind::SAVEPOINT_KW, - SyntaxKind::SCALAR_KW, - SyntaxKind::SCHEMA_KW, - SyntaxKind::SCHEMAS_KW, - SyntaxKind::SCROLL_KW, - SyntaxKind::SEARCH_KW, - SyntaxKind::SECOND_KW, - SyntaxKind::SECURITY_KW, - SyntaxKind::SEQUENCE_KW, - SyntaxKind::SEQUENCES_KW, - SyntaxKind::SERIALIZABLE_KW, - SyntaxKind::SERVER_KW, - SyntaxKind::SESSION_KW, - SyntaxKind::SET_KW, - SyntaxKind::SETOF_KW, - SyntaxKind::SETS_KW, - SyntaxKind::SHARE_KW, - SyntaxKind::SHOW_KW, - SyntaxKind::SIMILAR_KW, - SyntaxKind::SIMPLE_KW, - SyntaxKind::SKIP_KW, - SyntaxKind::SMALLINT_KW, - SyntaxKind::SNAPSHOT_KW, - SyntaxKind::SOURCE_KW, - SyntaxKind::SQL_KW, - SyntaxKind::STABLE_KW, - SyntaxKind::STANDALONE_KW, - SyntaxKind::START_KW, - SyntaxKind::STATEMENT_KW, - SyntaxKind::STATISTICS_KW, - SyntaxKind::STDIN_KW, - SyntaxKind::STDOUT_KW, - SyntaxKind::STORAGE_KW, - SyntaxKind::STORED_KW, - SyntaxKind::STRICT_KW, - SyntaxKind::STRING_KW, - SyntaxKind::STRIP_KW, - SyntaxKind::SUBSCRIPTION_KW, - SyntaxKind::SUBSTRING_KW, - SyntaxKind::SUPPORT_KW, - SyntaxKind::SYSID_KW, - SyntaxKind::SYSTEM_KW, - SyntaxKind::TABLES_KW, - SyntaxKind::TABLESAMPLE_KW, - SyntaxKind::TABLESPACE_KW, - SyntaxKind::TARGET_KW, - SyntaxKind::TEMP_KW, - SyntaxKind::TEMPLATE_KW, - SyntaxKind::TEMPORARY_KW, - SyntaxKind::TEXT_KW, - SyntaxKind::TIES_KW, - SyntaxKind::TIME_KW, - SyntaxKind::TIMESTAMP_KW, - SyntaxKind::TRANSACTION_KW, - SyntaxKind::TRANSFORM_KW, - SyntaxKind::TREAT_KW, - SyntaxKind::TRIGGER_KW, - SyntaxKind::TRIM_KW, - SyntaxKind::TRUNCATE_KW, - SyntaxKind::TRUSTED_KW, - SyntaxKind::TYPE_KW, - SyntaxKind::TYPES_KW, - SyntaxKind::UESCAPE_KW, - SyntaxKind::UNBOUNDED_KW, - SyntaxKind::UNCOMMITTED_KW, - SyntaxKind::UNCONDITIONAL_KW, - SyntaxKind::UNENCRYPTED_KW, - SyntaxKind::UNKNOWN_KW, - SyntaxKind::UNLISTEN_KW, - SyntaxKind::UNLOGGED_KW, - SyntaxKind::UNTIL_KW, - SyntaxKind::UPDATE_KW, - SyntaxKind::VACUUM_KW, - SyntaxKind::VALID_KW, - SyntaxKind::VALIDATE_KW, - SyntaxKind::VALIDATOR_KW, - SyntaxKind::VALUE_KW, - SyntaxKind::VALUES_KW, - SyntaxKind::VARCHAR_KW, - SyntaxKind::VARYING_KW, - SyntaxKind::VERBOSE_KW, - SyntaxKind::VERSION_KW, - SyntaxKind::VIEW_KW, - SyntaxKind::VIEWS_KW, - SyntaxKind::VOLATILE_KW, - SyntaxKind::WHITESPACE_KW, - SyntaxKind::WITHIN_KW, - SyntaxKind::WITHOUT_KW, - SyntaxKind::WORK_KW, - SyntaxKind::WRAPPER_KW, - SyntaxKind::WRITE_KW, - SyntaxKind::XML_KW, - SyntaxKind::XMLATTRIBUTES_KW, - SyntaxKind::XMLCONCAT_KW, - SyntaxKind::XMLELEMENT_KW, - SyntaxKind::XMLEXISTS_KW, - SyntaxKind::XMLFOREST_KW, - SyntaxKind::XMLNAMESPACES_KW, - SyntaxKind::XMLPARSE_KW, - SyntaxKind::XMLPI_KW, - SyntaxKind::XMLROOT_KW, - SyntaxKind::XMLSERIALIZE_KW, - SyntaxKind::XMLTABLE_KW, - SyntaxKind::YEAR_KW, - SyntaxKind::YES_KW, - SyntaxKind::ZONE_KW, -]); - -pub(crate) const ALL_KEYWORDS: TokenSet = TokenSet::new(&[ - SyntaxKind::ABORT_KW, - SyntaxKind::ABSENT_KW, - SyntaxKind::ABSOLUTE_KW, - SyntaxKind::ACCESS_KW, - SyntaxKind::ACTION_KW, - SyntaxKind::ADD_KW, - SyntaxKind::ADMIN_KW, - SyntaxKind::AFTER_KW, - SyntaxKind::AGGREGATE_KW, - SyntaxKind::ALL_KW, - SyntaxKind::ALSO_KW, - SyntaxKind::ALTER_KW, - SyntaxKind::ALWAYS_KW, - SyntaxKind::ANALYSE_KW, - SyntaxKind::ANALYZE_KW, - SyntaxKind::AND_KW, - SyntaxKind::ANY_KW, - SyntaxKind::ARRAY_KW, - SyntaxKind::AS_KW, - SyntaxKind::ASC_KW, - SyntaxKind::ASENSITIVE_KW, - SyntaxKind::ASSERTION_KW, - SyntaxKind::ASSIGNMENT_KW, - SyntaxKind::ASYMMETRIC_KW, - SyntaxKind::AT_KW, - SyntaxKind::ATOMIC_KW, - SyntaxKind::ATTACH_KW, - SyntaxKind::ATTRIBUTE_KW, - SyntaxKind::AUTHORIZATION_KW, - SyntaxKind::BACKWARD_KW, - SyntaxKind::BEFORE_KW, - SyntaxKind::BEGIN_KW, - SyntaxKind::BETWEEN_KW, - SyntaxKind::BIGINT_KW, - SyntaxKind::BINARY_KW, - SyntaxKind::BIT_KW, - SyntaxKind::BOOLEAN_KW, - SyntaxKind::BOTH_KW, - SyntaxKind::BREADTH_KW, - SyntaxKind::BY_KW, - SyntaxKind::CACHE_KW, - SyntaxKind::CALL_KW, - SyntaxKind::CALLED_KW, - SyntaxKind::CASCADE_KW, - SyntaxKind::CASCADED_KW, - SyntaxKind::CASE_KW, - SyntaxKind::CAST_KW, - SyntaxKind::CATALOG_KW, - SyntaxKind::CHAIN_KW, - SyntaxKind::CHAR_KW, - SyntaxKind::CHARACTER_KW, - SyntaxKind::CHARACTERISTICS_KW, - SyntaxKind::CHECK_KW, - SyntaxKind::CHECKPOINT_KW, - SyntaxKind::CLASS_KW, - SyntaxKind::CLOSE_KW, - SyntaxKind::CLUSTER_KW, - SyntaxKind::COALESCE_KW, - SyntaxKind::COLLATE_KW, - SyntaxKind::COLLATION_KW, - SyntaxKind::COLUMN_KW, - SyntaxKind::COLUMNS_KW, - SyntaxKind::COMMENT_KW, - SyntaxKind::COMMENTS_KW, - SyntaxKind::COMMIT_KW, - SyntaxKind::COMMITTED_KW, - SyntaxKind::COMPRESSION_KW, - SyntaxKind::CONCURRENTLY_KW, - SyntaxKind::CONDITIONAL_KW, - SyntaxKind::CONFIGURATION_KW, - SyntaxKind::CONFLICT_KW, - SyntaxKind::CONNECTION_KW, - SyntaxKind::CONSTRAINT_KW, - SyntaxKind::CONSTRAINTS_KW, - SyntaxKind::CONTENT_KW, - SyntaxKind::CONTINUE_KW, - SyntaxKind::CONVERSION_KW, - SyntaxKind::COPY_KW, - SyntaxKind::COST_KW, - SyntaxKind::CREATE_KW, - SyntaxKind::CROSS_KW, - SyntaxKind::CSV_KW, - SyntaxKind::CUBE_KW, - SyntaxKind::CURRENT_KW, - SyntaxKind::CURRENT_CATALOG_KW, - SyntaxKind::CURRENT_DATE_KW, - SyntaxKind::CURRENT_ROLE_KW, - SyntaxKind::CURRENT_SCHEMA_KW, - SyntaxKind::CURRENT_TIME_KW, - SyntaxKind::CURRENT_TIMESTAMP_KW, - SyntaxKind::CURRENT_USER_KW, - SyntaxKind::CURSOR_KW, - SyntaxKind::CYCLE_KW, - SyntaxKind::DATA_KW, - SyntaxKind::DATABASE_KW, - SyntaxKind::DAY_KW, - SyntaxKind::DEALLOCATE_KW, - SyntaxKind::DEC_KW, - SyntaxKind::DECIMAL_KW, - SyntaxKind::DECLARE_KW, - SyntaxKind::DEFAULT_KW, - SyntaxKind::DEFAULTS_KW, - SyntaxKind::DEFERRABLE_KW, - SyntaxKind::DEFERRED_KW, - SyntaxKind::DEFINER_KW, - SyntaxKind::DELETE_KW, - SyntaxKind::DELIMITER_KW, - SyntaxKind::DELIMITERS_KW, - SyntaxKind::DEPENDS_KW, - SyntaxKind::DEPTH_KW, - SyntaxKind::DESC_KW, - SyntaxKind::DETACH_KW, - SyntaxKind::DICTIONARY_KW, - SyntaxKind::DISABLE_KW, - SyntaxKind::DISCARD_KW, - SyntaxKind::DISTINCT_KW, - SyntaxKind::DO_KW, - SyntaxKind::DOCUMENT_KW, - SyntaxKind::DOMAIN_KW, - SyntaxKind::DOUBLE_KW, - SyntaxKind::DROP_KW, - SyntaxKind::EACH_KW, - SyntaxKind::ELSE_KW, - SyntaxKind::EMPTY_KW, - SyntaxKind::ENABLE_KW, - SyntaxKind::ENCODING_KW, - SyntaxKind::ENCRYPTED_KW, - SyntaxKind::END_KW, - SyntaxKind::ENUM_KW, - SyntaxKind::ERROR_KW, - SyntaxKind::ESCAPE_KW, - SyntaxKind::EVENT_KW, - SyntaxKind::EXCEPT_KW, - SyntaxKind::EXCLUDE_KW, - SyntaxKind::EXCLUDING_KW, - SyntaxKind::EXCLUSIVE_KW, - SyntaxKind::EXECUTE_KW, - SyntaxKind::EXISTS_KW, - SyntaxKind::EXPLAIN_KW, - SyntaxKind::EXPRESSION_KW, - SyntaxKind::EXTENSION_KW, - SyntaxKind::EXTERNAL_KW, - SyntaxKind::EXTRACT_KW, - SyntaxKind::FALSE_KW, - SyntaxKind::FAMILY_KW, - SyntaxKind::FETCH_KW, - SyntaxKind::FILTER_KW, - SyntaxKind::FINALIZE_KW, - SyntaxKind::FIRST_KW, - SyntaxKind::FLOAT_KW, - SyntaxKind::FOLLOWING_KW, - SyntaxKind::FOR_KW, - SyntaxKind::FORCE_KW, - SyntaxKind::FOREIGN_KW, - SyntaxKind::FORMAT_KW, - SyntaxKind::FORWARD_KW, - SyntaxKind::FREEZE_KW, - SyntaxKind::FROM_KW, - SyntaxKind::FULL_KW, - SyntaxKind::FUNCTION_KW, - SyntaxKind::FUNCTIONS_KW, - SyntaxKind::GENERATED_KW, - SyntaxKind::GLOBAL_KW, - SyntaxKind::GRANT_KW, - SyntaxKind::GRANTED_KW, - SyntaxKind::GREATEST_KW, - SyntaxKind::GROUP_KW, - SyntaxKind::GROUPING_KW, - SyntaxKind::GROUPS_KW, - SyntaxKind::HANDLER_KW, - SyntaxKind::HAVING_KW, - SyntaxKind::HEADER_KW, - SyntaxKind::HOLD_KW, - SyntaxKind::HOUR_KW, - SyntaxKind::IDENTITY_KW, - SyntaxKind::IF_KW, - SyntaxKind::ILIKE_KW, - SyntaxKind::IMMEDIATE_KW, - SyntaxKind::IMMUTABLE_KW, - SyntaxKind::IMPLICIT_KW, - SyntaxKind::IMPORT_KW, - SyntaxKind::IN_KW, - SyntaxKind::INCLUDE_KW, - SyntaxKind::INCLUDING_KW, - SyntaxKind::INCREMENT_KW, - SyntaxKind::INDENT_KW, - SyntaxKind::INDEX_KW, - SyntaxKind::INDEXES_KW, - SyntaxKind::INHERIT_KW, - SyntaxKind::INHERITS_KW, - SyntaxKind::INITIALLY_KW, - SyntaxKind::INLINE_KW, - SyntaxKind::INNER_KW, - SyntaxKind::INOUT_KW, - SyntaxKind::INPUT_KW, - SyntaxKind::INSENSITIVE_KW, - SyntaxKind::INSERT_KW, - SyntaxKind::INSTEAD_KW, - SyntaxKind::INT_KW, - SyntaxKind::INTEGER_KW, - SyntaxKind::INTERSECT_KW, - SyntaxKind::INTERVAL_KW, - SyntaxKind::INTO_KW, - SyntaxKind::INVOKER_KW, - SyntaxKind::IS_KW, - SyntaxKind::ISNULL_KW, - SyntaxKind::ISOLATION_KW, - SyntaxKind::JOIN_KW, - SyntaxKind::JSON_KW, - SyntaxKind::JSON_ARRAY_KW, - SyntaxKind::JSON_ARRAYAGG_KW, - SyntaxKind::JSON_EXISTS_KW, - SyntaxKind::JSON_OBJECT_KW, - SyntaxKind::JSON_OBJECTAGG_KW, - SyntaxKind::JSON_QUERY_KW, - SyntaxKind::JSON_SCALAR_KW, - SyntaxKind::JSON_SERIALIZE_KW, - SyntaxKind::JSON_TABLE_KW, - SyntaxKind::JSON_VALUE_KW, - SyntaxKind::KEEP_KW, - SyntaxKind::KEY_KW, - SyntaxKind::KEYS_KW, - SyntaxKind::LABEL_KW, - SyntaxKind::LANGUAGE_KW, - SyntaxKind::LARGE_KW, - SyntaxKind::LAST_KW, - SyntaxKind::LATERAL_KW, - SyntaxKind::LEADING_KW, - SyntaxKind::LEAKPROOF_KW, - SyntaxKind::LEAST_KW, - SyntaxKind::LEFT_KW, - SyntaxKind::LEVEL_KW, - SyntaxKind::LIKE_KW, - SyntaxKind::LIMIT_KW, - SyntaxKind::LISTEN_KW, - SyntaxKind::LOAD_KW, - SyntaxKind::LOCAL_KW, - SyntaxKind::LOCALTIME_KW, - SyntaxKind::LOCALTIMESTAMP_KW, - SyntaxKind::LOCATION_KW, - SyntaxKind::LOCK_KW, - SyntaxKind::LOCKED_KW, - SyntaxKind::LOGGED_KW, - SyntaxKind::MAPPING_KW, - SyntaxKind::MATCH_KW, - SyntaxKind::MATCHED_KW, - SyntaxKind::MATERIALIZED_KW, - SyntaxKind::MAXVALUE_KW, - SyntaxKind::MERGE_KW, - SyntaxKind::MERGE_ACTION_KW, - SyntaxKind::METHOD_KW, - SyntaxKind::MINUTE_KW, - SyntaxKind::MINVALUE_KW, - SyntaxKind::MODE_KW, - SyntaxKind::MONTH_KW, - SyntaxKind::MOVE_KW, - SyntaxKind::NAME_KW, - SyntaxKind::NAMES_KW, - SyntaxKind::NATIONAL_KW, - SyntaxKind::NATURAL_KW, - SyntaxKind::NCHAR_KW, - SyntaxKind::NESTED_KW, - SyntaxKind::NEW_KW, - SyntaxKind::NEXT_KW, - SyntaxKind::NFC_KW, - SyntaxKind::NFD_KW, - SyntaxKind::NFKC_KW, - SyntaxKind::NFKD_KW, - SyntaxKind::NO_KW, - SyntaxKind::NONE_KW, - SyntaxKind::NORMALIZE_KW, - SyntaxKind::NORMALIZED_KW, - SyntaxKind::NOT_KW, - SyntaxKind::NOTHING_KW, - SyntaxKind::NOTIFY_KW, - SyntaxKind::NOTNULL_KW, - SyntaxKind::NOWAIT_KW, - SyntaxKind::NULL_KW, - SyntaxKind::NULLIF_KW, - SyntaxKind::NULLS_KW, - SyntaxKind::NUMERIC_KW, - SyntaxKind::OBJECT_KW, - SyntaxKind::OF_KW, - SyntaxKind::OFF_KW, - SyntaxKind::OFFSET_KW, - SyntaxKind::OIDS_KW, - SyntaxKind::OLD_KW, - SyntaxKind::OMIT_KW, - SyntaxKind::ON_KW, - SyntaxKind::ONLY_KW, - SyntaxKind::OPERATOR_KW, - SyntaxKind::OPTION_KW, - SyntaxKind::OPTIONS_KW, - SyntaxKind::OR_KW, - SyntaxKind::ORDER_KW, - SyntaxKind::ORDINALITY_KW, - SyntaxKind::OTHERS_KW, - SyntaxKind::OUT_KW, - SyntaxKind::OUTER_KW, - SyntaxKind::OVER_KW, - SyntaxKind::OVERLAPS_KW, - SyntaxKind::OVERLAY_KW, - SyntaxKind::OVERRIDING_KW, - SyntaxKind::OWNED_KW, - SyntaxKind::OWNER_KW, - SyntaxKind::PARALLEL_KW, - SyntaxKind::PARAMETER_KW, - SyntaxKind::PARSER_KW, - SyntaxKind::PARTIAL_KW, - SyntaxKind::PARTITION_KW, - SyntaxKind::PASSING_KW, - SyntaxKind::PASSWORD_KW, - SyntaxKind::PATH_KW, - SyntaxKind::PERIOD_KW, - SyntaxKind::PLACING_KW, - SyntaxKind::PLAN_KW, - SyntaxKind::PLANS_KW, - SyntaxKind::POLICY_KW, - SyntaxKind::POSITION_KW, - SyntaxKind::PRECEDING_KW, - SyntaxKind::PRECISION_KW, - SyntaxKind::PREPARE_KW, - SyntaxKind::PREPARED_KW, - SyntaxKind::PRESERVE_KW, - SyntaxKind::PRIMARY_KW, - SyntaxKind::PRIOR_KW, - SyntaxKind::PRIVILEGES_KW, - SyntaxKind::PROCEDURAL_KW, - SyntaxKind::PROCEDURE_KW, - SyntaxKind::PROCEDURES_KW, - SyntaxKind::PROGRAM_KW, - SyntaxKind::PUBLICATION_KW, - SyntaxKind::QUOTE_KW, - SyntaxKind::QUOTES_KW, - SyntaxKind::RANGE_KW, - SyntaxKind::READ_KW, - SyntaxKind::REAL_KW, - SyntaxKind::REASSIGN_KW, - SyntaxKind::RECURSIVE_KW, - SyntaxKind::REF_KW, - SyntaxKind::REFERENCES_KW, - SyntaxKind::REFERENCING_KW, - SyntaxKind::REFRESH_KW, - SyntaxKind::REINDEX_KW, - SyntaxKind::RELATIVE_KW, - SyntaxKind::RELEASE_KW, - SyntaxKind::RENAME_KW, - SyntaxKind::REPEATABLE_KW, - SyntaxKind::REPLACE_KW, - SyntaxKind::REPLICA_KW, - SyntaxKind::RESET_KW, - SyntaxKind::RESTART_KW, - SyntaxKind::RESTRICT_KW, - SyntaxKind::RETURN_KW, - SyntaxKind::RETURNING_KW, - SyntaxKind::RETURNS_KW, - SyntaxKind::REVOKE_KW, - SyntaxKind::RIGHT_KW, - SyntaxKind::ROLE_KW, - SyntaxKind::ROLLBACK_KW, - SyntaxKind::ROLLUP_KW, - SyntaxKind::ROUTINE_KW, - SyntaxKind::ROUTINES_KW, - SyntaxKind::ROW_KW, - SyntaxKind::ROWS_KW, - SyntaxKind::RULE_KW, - SyntaxKind::SAVEPOINT_KW, - SyntaxKind::SCALAR_KW, - SyntaxKind::SCHEMA_KW, - SyntaxKind::SCHEMAS_KW, - SyntaxKind::SCROLL_KW, - SyntaxKind::SEARCH_KW, - SyntaxKind::SECOND_KW, - SyntaxKind::SECURITY_KW, - SyntaxKind::SELECT_KW, - SyntaxKind::SEQUENCE_KW, - SyntaxKind::SEQUENCES_KW, - SyntaxKind::SERIALIZABLE_KW, - SyntaxKind::SERVER_KW, - SyntaxKind::SESSION_KW, - SyntaxKind::SESSION_USER_KW, - SyntaxKind::SET_KW, - SyntaxKind::SETOF_KW, - SyntaxKind::SETS_KW, - SyntaxKind::SHARE_KW, - SyntaxKind::SHOW_KW, - SyntaxKind::SIMILAR_KW, - SyntaxKind::SIMPLE_KW, - SyntaxKind::SKIP_KW, - SyntaxKind::SMALLINT_KW, - SyntaxKind::SNAPSHOT_KW, - SyntaxKind::SOME_KW, - SyntaxKind::SOURCE_KW, - SyntaxKind::SQL_KW, - SyntaxKind::STABLE_KW, - SyntaxKind::STANDALONE_KW, - SyntaxKind::START_KW, - SyntaxKind::STATEMENT_KW, - SyntaxKind::STATISTICS_KW, - SyntaxKind::STDIN_KW, - SyntaxKind::STDOUT_KW, - SyntaxKind::STORAGE_KW, - SyntaxKind::STORED_KW, - SyntaxKind::STRICT_KW, - SyntaxKind::STRING_KW, - SyntaxKind::STRIP_KW, - SyntaxKind::SUBSCRIPTION_KW, - SyntaxKind::SUBSTRING_KW, - SyntaxKind::SUPPORT_KW, - SyntaxKind::SYMMETRIC_KW, - SyntaxKind::SYSID_KW, - SyntaxKind::SYSTEM_KW, - SyntaxKind::SYSTEM_USER_KW, - SyntaxKind::TABLE_KW, - SyntaxKind::TABLES_KW, - SyntaxKind::TABLESAMPLE_KW, - SyntaxKind::TABLESPACE_KW, - SyntaxKind::TARGET_KW, - SyntaxKind::TEMP_KW, - SyntaxKind::TEMPLATE_KW, - SyntaxKind::TEMPORARY_KW, - SyntaxKind::TEXT_KW, - SyntaxKind::THEN_KW, - SyntaxKind::TIES_KW, - SyntaxKind::TIME_KW, - SyntaxKind::TIMESTAMP_KW, - SyntaxKind::TO_KW, - SyntaxKind::TRAILING_KW, - SyntaxKind::TRANSACTION_KW, - SyntaxKind::TRANSFORM_KW, - SyntaxKind::TREAT_KW, - SyntaxKind::TRIGGER_KW, - SyntaxKind::TRIM_KW, - SyntaxKind::TRUE_KW, - SyntaxKind::TRUNCATE_KW, - SyntaxKind::TRUSTED_KW, - SyntaxKind::TYPE_KW, - SyntaxKind::TYPES_KW, - SyntaxKind::UESCAPE_KW, - SyntaxKind::UNBOUNDED_KW, - SyntaxKind::UNCOMMITTED_KW, - SyntaxKind::UNCONDITIONAL_KW, - SyntaxKind::UNENCRYPTED_KW, - SyntaxKind::UNION_KW, - SyntaxKind::UNIQUE_KW, - SyntaxKind::UNKNOWN_KW, - SyntaxKind::UNLISTEN_KW, - SyntaxKind::UNLOGGED_KW, - SyntaxKind::UNTIL_KW, - SyntaxKind::UPDATE_KW, - SyntaxKind::USER_KW, - SyntaxKind::USING_KW, - SyntaxKind::VACUUM_KW, - SyntaxKind::VALID_KW, - SyntaxKind::VALIDATE_KW, - SyntaxKind::VALIDATOR_KW, - SyntaxKind::VALUE_KW, - SyntaxKind::VALUES_KW, - SyntaxKind::VARCHAR_KW, - SyntaxKind::VARIADIC_KW, - SyntaxKind::VARYING_KW, - SyntaxKind::VERBOSE_KW, - SyntaxKind::VERSION_KW, - SyntaxKind::VIEW_KW, - SyntaxKind::VIEWS_KW, - SyntaxKind::VOLATILE_KW, - SyntaxKind::WHEN_KW, - SyntaxKind::WHERE_KW, - SyntaxKind::WHITESPACE_KW, - SyntaxKind::WINDOW_KW, - SyntaxKind::WITH_KW, - SyntaxKind::WITHIN_KW, - SyntaxKind::WITHOUT_KW, - SyntaxKind::WORK_KW, - SyntaxKind::WRAPPER_KW, - SyntaxKind::WRITE_KW, - SyntaxKind::XML_KW, - SyntaxKind::XMLATTRIBUTES_KW, - SyntaxKind::XMLCONCAT_KW, - SyntaxKind::XMLELEMENT_KW, - SyntaxKind::XMLEXISTS_KW, - SyntaxKind::XMLFOREST_KW, - SyntaxKind::XMLNAMESPACES_KW, - SyntaxKind::XMLPARSE_KW, - SyntaxKind::XMLPI_KW, - SyntaxKind::XMLROOT_KW, - SyntaxKind::XMLSERIALIZE_KW, - SyntaxKind::XMLTABLE_KW, - SyntaxKind::YEAR_KW, - SyntaxKind::YES_KW, - SyntaxKind::ZONE_KW, -]); - -pub(crate) const BARE_LABEL_KEYWORDS: TokenSet = TokenSet::new(&[ - SyntaxKind::ABORT_KW, - SyntaxKind::ABSENT_KW, - SyntaxKind::ABSOLUTE_KW, - SyntaxKind::ACCESS_KW, - SyntaxKind::ACTION_KW, - SyntaxKind::ADD_KW, - SyntaxKind::ADMIN_KW, - SyntaxKind::AFTER_KW, - SyntaxKind::AGGREGATE_KW, - SyntaxKind::ALL_KW, - SyntaxKind::ALSO_KW, - SyntaxKind::ALTER_KW, - SyntaxKind::ALWAYS_KW, - SyntaxKind::ANALYSE_KW, - SyntaxKind::ANALYZE_KW, - SyntaxKind::AND_KW, - SyntaxKind::ANY_KW, - SyntaxKind::ASC_KW, - SyntaxKind::ASENSITIVE_KW, - SyntaxKind::ASSERTION_KW, - SyntaxKind::ASSIGNMENT_KW, - SyntaxKind::ASYMMETRIC_KW, - SyntaxKind::AT_KW, - SyntaxKind::ATOMIC_KW, - SyntaxKind::ATTACH_KW, - SyntaxKind::ATTRIBUTE_KW, - SyntaxKind::AUTHORIZATION_KW, - SyntaxKind::BACKWARD_KW, - SyntaxKind::BEFORE_KW, - SyntaxKind::BEGIN_KW, - SyntaxKind::BETWEEN_KW, - SyntaxKind::BIGINT_KW, - SyntaxKind::BINARY_KW, - SyntaxKind::BIT_KW, - SyntaxKind::BOOLEAN_KW, - SyntaxKind::BOTH_KW, - SyntaxKind::BREADTH_KW, - SyntaxKind::BY_KW, - SyntaxKind::CACHE_KW, - SyntaxKind::CALL_KW, - SyntaxKind::CALLED_KW, - SyntaxKind::CASCADE_KW, - SyntaxKind::CASCADED_KW, - SyntaxKind::CASE_KW, - SyntaxKind::CAST_KW, - SyntaxKind::CATALOG_KW, - SyntaxKind::CHAIN_KW, - SyntaxKind::CHARACTERISTICS_KW, - SyntaxKind::CHECK_KW, - SyntaxKind::CHECKPOINT_KW, - SyntaxKind::CLASS_KW, - SyntaxKind::CLOSE_KW, - SyntaxKind::CLUSTER_KW, - SyntaxKind::COALESCE_KW, - SyntaxKind::COLLATE_KW, - SyntaxKind::COLLATION_KW, - SyntaxKind::COLUMN_KW, - SyntaxKind::COLUMNS_KW, - SyntaxKind::COMMENT_KW, - SyntaxKind::COMMENTS_KW, - SyntaxKind::COMMIT_KW, - SyntaxKind::COMMITTED_KW, - SyntaxKind::COMPRESSION_KW, - SyntaxKind::CONCURRENTLY_KW, - SyntaxKind::CONDITIONAL_KW, - SyntaxKind::CONFIGURATION_KW, - SyntaxKind::CONFLICT_KW, - SyntaxKind::CONNECTION_KW, - SyntaxKind::CONSTRAINT_KW, - SyntaxKind::CONSTRAINTS_KW, - SyntaxKind::CONTENT_KW, - SyntaxKind::CONTINUE_KW, - SyntaxKind::CONVERSION_KW, - SyntaxKind::COPY_KW, - SyntaxKind::COST_KW, - SyntaxKind::CROSS_KW, - SyntaxKind::CSV_KW, - SyntaxKind::CUBE_KW, - SyntaxKind::CURRENT_KW, - SyntaxKind::CURRENT_CATALOG_KW, - SyntaxKind::CURRENT_DATE_KW, - SyntaxKind::CURRENT_ROLE_KW, - SyntaxKind::CURRENT_SCHEMA_KW, - SyntaxKind::CURRENT_TIME_KW, - SyntaxKind::CURRENT_TIMESTAMP_KW, - SyntaxKind::CURRENT_USER_KW, - SyntaxKind::CURSOR_KW, - SyntaxKind::CYCLE_KW, - SyntaxKind::DATA_KW, - SyntaxKind::DATABASE_KW, - SyntaxKind::DEALLOCATE_KW, - SyntaxKind::DEC_KW, - SyntaxKind::DECIMAL_KW, - SyntaxKind::DECLARE_KW, - SyntaxKind::DEFAULT_KW, - SyntaxKind::DEFAULTS_KW, - SyntaxKind::DEFERRABLE_KW, - SyntaxKind::DEFERRED_KW, - SyntaxKind::DEFINER_KW, - SyntaxKind::DELETE_KW, - SyntaxKind::DELIMITER_KW, - SyntaxKind::DELIMITERS_KW, - SyntaxKind::DEPENDS_KW, - SyntaxKind::DEPTH_KW, - SyntaxKind::DESC_KW, - SyntaxKind::DETACH_KW, - SyntaxKind::DICTIONARY_KW, - SyntaxKind::DISABLE_KW, - SyntaxKind::DISCARD_KW, - SyntaxKind::DISTINCT_KW, - SyntaxKind::DO_KW, - SyntaxKind::DOCUMENT_KW, - SyntaxKind::DOMAIN_KW, - SyntaxKind::DOUBLE_KW, - SyntaxKind::DROP_KW, - SyntaxKind::EACH_KW, - SyntaxKind::ELSE_KW, - SyntaxKind::EMPTY_KW, - SyntaxKind::ENABLE_KW, - SyntaxKind::ENCODING_KW, - SyntaxKind::ENCRYPTED_KW, - SyntaxKind::END_KW, - SyntaxKind::ENUM_KW, - SyntaxKind::ERROR_KW, - SyntaxKind::ESCAPE_KW, - SyntaxKind::EVENT_KW, - SyntaxKind::EXCLUDE_KW, - SyntaxKind::EXCLUDING_KW, - SyntaxKind::EXCLUSIVE_KW, - SyntaxKind::EXECUTE_KW, - SyntaxKind::EXISTS_KW, - SyntaxKind::EXPLAIN_KW, - SyntaxKind::EXPRESSION_KW, - SyntaxKind::EXTENSION_KW, - SyntaxKind::EXTERNAL_KW, - SyntaxKind::EXTRACT_KW, - SyntaxKind::FALSE_KW, - SyntaxKind::FAMILY_KW, - SyntaxKind::FINALIZE_KW, - SyntaxKind::FIRST_KW, - SyntaxKind::FLOAT_KW, - SyntaxKind::FOLLOWING_KW, - SyntaxKind::FORCE_KW, - SyntaxKind::FOREIGN_KW, - SyntaxKind::FORMAT_KW, - SyntaxKind::FORWARD_KW, - SyntaxKind::FREEZE_KW, - SyntaxKind::FULL_KW, - SyntaxKind::FUNCTION_KW, - SyntaxKind::FUNCTIONS_KW, - SyntaxKind::GENERATED_KW, - SyntaxKind::GLOBAL_KW, - SyntaxKind::GRANTED_KW, - SyntaxKind::GREATEST_KW, - SyntaxKind::GROUPING_KW, - SyntaxKind::GROUPS_KW, - SyntaxKind::HANDLER_KW, - SyntaxKind::HEADER_KW, - SyntaxKind::HOLD_KW, - SyntaxKind::IDENTITY_KW, - SyntaxKind::IF_KW, - SyntaxKind::ILIKE_KW, - SyntaxKind::IMMEDIATE_KW, - SyntaxKind::IMMUTABLE_KW, - SyntaxKind::IMPLICIT_KW, - SyntaxKind::IMPORT_KW, - SyntaxKind::IN_KW, - SyntaxKind::INCLUDE_KW, - SyntaxKind::INCLUDING_KW, - SyntaxKind::INCREMENT_KW, - SyntaxKind::INDENT_KW, - SyntaxKind::INDEX_KW, - SyntaxKind::INDEXES_KW, - SyntaxKind::INHERIT_KW, - SyntaxKind::INHERITS_KW, - SyntaxKind::INITIALLY_KW, - SyntaxKind::INLINE_KW, - SyntaxKind::INNER_KW, - SyntaxKind::INOUT_KW, - SyntaxKind::INPUT_KW, - SyntaxKind::INSENSITIVE_KW, - SyntaxKind::INSERT_KW, - SyntaxKind::INSTEAD_KW, - SyntaxKind::INT_KW, - SyntaxKind::INTEGER_KW, - SyntaxKind::INTERVAL_KW, - SyntaxKind::INVOKER_KW, - SyntaxKind::IS_KW, - SyntaxKind::ISOLATION_KW, - SyntaxKind::JOIN_KW, - SyntaxKind::JSON_KW, - SyntaxKind::JSON_ARRAY_KW, - SyntaxKind::JSON_ARRAYAGG_KW, - SyntaxKind::JSON_EXISTS_KW, - SyntaxKind::JSON_OBJECT_KW, - SyntaxKind::JSON_OBJECTAGG_KW, - SyntaxKind::JSON_QUERY_KW, - SyntaxKind::JSON_SCALAR_KW, - SyntaxKind::JSON_SERIALIZE_KW, - SyntaxKind::JSON_TABLE_KW, - SyntaxKind::JSON_VALUE_KW, - SyntaxKind::KEEP_KW, - SyntaxKind::KEY_KW, - SyntaxKind::KEYS_KW, - SyntaxKind::LABEL_KW, - SyntaxKind::LANGUAGE_KW, - SyntaxKind::LARGE_KW, - SyntaxKind::LAST_KW, - SyntaxKind::LATERAL_KW, - SyntaxKind::LEADING_KW, - SyntaxKind::LEAKPROOF_KW, - SyntaxKind::LEAST_KW, - SyntaxKind::LEFT_KW, - SyntaxKind::LEVEL_KW, - SyntaxKind::LIKE_KW, - SyntaxKind::LISTEN_KW, - SyntaxKind::LOAD_KW, - SyntaxKind::LOCAL_KW, - SyntaxKind::LOCALTIME_KW, - SyntaxKind::LOCALTIMESTAMP_KW, - SyntaxKind::LOCATION_KW, - SyntaxKind::LOCK_KW, - SyntaxKind::LOCKED_KW, - SyntaxKind::LOGGED_KW, - SyntaxKind::MAPPING_KW, - SyntaxKind::MATCH_KW, - SyntaxKind::MATCHED_KW, - SyntaxKind::MATERIALIZED_KW, - SyntaxKind::MAXVALUE_KW, - SyntaxKind::MERGE_KW, - SyntaxKind::MERGE_ACTION_KW, - SyntaxKind::METHOD_KW, - SyntaxKind::MINVALUE_KW, - SyntaxKind::MODE_KW, - SyntaxKind::MOVE_KW, - SyntaxKind::NAME_KW, - SyntaxKind::NAMES_KW, - SyntaxKind::NATIONAL_KW, - SyntaxKind::NATURAL_KW, - SyntaxKind::NCHAR_KW, - SyntaxKind::NESTED_KW, - SyntaxKind::NEW_KW, - SyntaxKind::NEXT_KW, - SyntaxKind::NFC_KW, - SyntaxKind::NFD_KW, - SyntaxKind::NFKC_KW, - SyntaxKind::NFKD_KW, - SyntaxKind::NO_KW, - SyntaxKind::NONE_KW, - SyntaxKind::NORMALIZE_KW, - SyntaxKind::NORMALIZED_KW, - SyntaxKind::NOT_KW, - SyntaxKind::NOTHING_KW, - SyntaxKind::NOTIFY_KW, - SyntaxKind::NOWAIT_KW, - SyntaxKind::NULL_KW, - SyntaxKind::NULLIF_KW, - SyntaxKind::NULLS_KW, - SyntaxKind::NUMERIC_KW, - SyntaxKind::OBJECT_KW, - SyntaxKind::OF_KW, - SyntaxKind::OFF_KW, - SyntaxKind::OIDS_KW, - SyntaxKind::OLD_KW, - SyntaxKind::OMIT_KW, - SyntaxKind::ONLY_KW, - SyntaxKind::OPERATOR_KW, - SyntaxKind::OPTION_KW, - SyntaxKind::OPTIONS_KW, - SyntaxKind::OR_KW, - SyntaxKind::ORDINALITY_KW, - SyntaxKind::OTHERS_KW, - SyntaxKind::OUT_KW, - SyntaxKind::OUTER_KW, - SyntaxKind::OVERLAY_KW, - SyntaxKind::OVERRIDING_KW, - SyntaxKind::OWNED_KW, - SyntaxKind::OWNER_KW, - SyntaxKind::PARALLEL_KW, - SyntaxKind::PARAMETER_KW, - SyntaxKind::PARSER_KW, - SyntaxKind::PARTIAL_KW, - SyntaxKind::PARTITION_KW, - SyntaxKind::PASSING_KW, - SyntaxKind::PASSWORD_KW, - SyntaxKind::PATH_KW, - SyntaxKind::PERIOD_KW, - SyntaxKind::PLACING_KW, - SyntaxKind::PLAN_KW, - SyntaxKind::PLANS_KW, - SyntaxKind::POLICY_KW, - SyntaxKind::POSITION_KW, - SyntaxKind::PRECEDING_KW, - SyntaxKind::PREPARE_KW, - SyntaxKind::PREPARED_KW, - SyntaxKind::PRESERVE_KW, - SyntaxKind::PRIMARY_KW, - SyntaxKind::PRIOR_KW, - SyntaxKind::PRIVILEGES_KW, - SyntaxKind::PROCEDURAL_KW, - SyntaxKind::PROCEDURE_KW, - SyntaxKind::PROCEDURES_KW, - SyntaxKind::PROGRAM_KW, - SyntaxKind::PUBLICATION_KW, - SyntaxKind::QUOTE_KW, - SyntaxKind::QUOTES_KW, - SyntaxKind::RANGE_KW, - SyntaxKind::READ_KW, - SyntaxKind::REAL_KW, - SyntaxKind::REASSIGN_KW, - SyntaxKind::RECURSIVE_KW, - SyntaxKind::REF_KW, - SyntaxKind::REFERENCES_KW, - SyntaxKind::REFERENCING_KW, - SyntaxKind::REFRESH_KW, - SyntaxKind::REINDEX_KW, - SyntaxKind::RELATIVE_KW, - SyntaxKind::RELEASE_KW, - SyntaxKind::RENAME_KW, - SyntaxKind::REPEATABLE_KW, - SyntaxKind::REPLACE_KW, - SyntaxKind::REPLICA_KW, - SyntaxKind::RESET_KW, - SyntaxKind::RESTART_KW, - SyntaxKind::RESTRICT_KW, - SyntaxKind::RETURN_KW, - SyntaxKind::RETURNS_KW, - SyntaxKind::REVOKE_KW, - SyntaxKind::RIGHT_KW, - SyntaxKind::ROLE_KW, - SyntaxKind::ROLLBACK_KW, - SyntaxKind::ROLLUP_KW, - SyntaxKind::ROUTINE_KW, - SyntaxKind::ROUTINES_KW, - SyntaxKind::ROW_KW, - SyntaxKind::ROWS_KW, - SyntaxKind::RULE_KW, - SyntaxKind::SAVEPOINT_KW, - SyntaxKind::SCALAR_KW, - SyntaxKind::SCHEMA_KW, - SyntaxKind::SCHEMAS_KW, - SyntaxKind::SCROLL_KW, - SyntaxKind::SEARCH_KW, - SyntaxKind::SECURITY_KW, - SyntaxKind::SELECT_KW, - SyntaxKind::SEQUENCE_KW, - SyntaxKind::SEQUENCES_KW, - SyntaxKind::SERIALIZABLE_KW, - SyntaxKind::SERVER_KW, - SyntaxKind::SESSION_KW, - SyntaxKind::SESSION_USER_KW, - SyntaxKind::SET_KW, - SyntaxKind::SETOF_KW, - SyntaxKind::SETS_KW, - SyntaxKind::SHARE_KW, - SyntaxKind::SHOW_KW, - SyntaxKind::SIMILAR_KW, - SyntaxKind::SIMPLE_KW, - SyntaxKind::SKIP_KW, - SyntaxKind::SMALLINT_KW, - SyntaxKind::SNAPSHOT_KW, - SyntaxKind::SOME_KW, - SyntaxKind::SOURCE_KW, - SyntaxKind::SQL_KW, - SyntaxKind::STABLE_KW, - SyntaxKind::STANDALONE_KW, - SyntaxKind::START_KW, - SyntaxKind::STATEMENT_KW, - SyntaxKind::STATISTICS_KW, - SyntaxKind::STDIN_KW, - SyntaxKind::STDOUT_KW, - SyntaxKind::STORAGE_KW, - SyntaxKind::STORED_KW, - SyntaxKind::STRICT_KW, - SyntaxKind::STRING_KW, - SyntaxKind::STRIP_KW, - SyntaxKind::SUBSCRIPTION_KW, - SyntaxKind::SUBSTRING_KW, - SyntaxKind::SUPPORT_KW, - SyntaxKind::SYMMETRIC_KW, - SyntaxKind::SYSID_KW, - SyntaxKind::SYSTEM_KW, - SyntaxKind::SYSTEM_USER_KW, - SyntaxKind::TABLE_KW, - SyntaxKind::TABLES_KW, - SyntaxKind::TABLESAMPLE_KW, - SyntaxKind::TABLESPACE_KW, - SyntaxKind::TARGET_KW, - SyntaxKind::TEMP_KW, - SyntaxKind::TEMPLATE_KW, - SyntaxKind::TEMPORARY_KW, - SyntaxKind::TEXT_KW, - SyntaxKind::THEN_KW, - SyntaxKind::TIES_KW, - SyntaxKind::TIME_KW, - SyntaxKind::TIMESTAMP_KW, - SyntaxKind::TRAILING_KW, - SyntaxKind::TRANSACTION_KW, - SyntaxKind::TRANSFORM_KW, - SyntaxKind::TREAT_KW, - SyntaxKind::TRIGGER_KW, - SyntaxKind::TRIM_KW, - SyntaxKind::TRUE_KW, - SyntaxKind::TRUNCATE_KW, - SyntaxKind::TRUSTED_KW, - SyntaxKind::TYPE_KW, - SyntaxKind::TYPES_KW, - SyntaxKind::UESCAPE_KW, - SyntaxKind::UNBOUNDED_KW, - SyntaxKind::UNCOMMITTED_KW, - SyntaxKind::UNCONDITIONAL_KW, - SyntaxKind::UNENCRYPTED_KW, - SyntaxKind::UNIQUE_KW, - SyntaxKind::UNKNOWN_KW, - SyntaxKind::UNLISTEN_KW, - SyntaxKind::UNLOGGED_KW, - SyntaxKind::UNTIL_KW, - SyntaxKind::UPDATE_KW, - SyntaxKind::USER_KW, - SyntaxKind::USING_KW, - SyntaxKind::VACUUM_KW, - SyntaxKind::VALID_KW, - SyntaxKind::VALIDATE_KW, - SyntaxKind::VALIDATOR_KW, - SyntaxKind::VALUE_KW, - SyntaxKind::VALUES_KW, - SyntaxKind::VARCHAR_KW, - SyntaxKind::VARIADIC_KW, - SyntaxKind::VERBOSE_KW, - SyntaxKind::VERSION_KW, - SyntaxKind::VIEW_KW, - SyntaxKind::VIEWS_KW, - SyntaxKind::VOLATILE_KW, - SyntaxKind::WHEN_KW, - SyntaxKind::WHITESPACE_KW, - SyntaxKind::WORK_KW, - SyntaxKind::WRAPPER_KW, - SyntaxKind::WRITE_KW, - SyntaxKind::XML_KW, - SyntaxKind::XMLATTRIBUTES_KW, - SyntaxKind::XMLCONCAT_KW, - SyntaxKind::XMLELEMENT_KW, - SyntaxKind::XMLEXISTS_KW, - SyntaxKind::XMLFOREST_KW, - SyntaxKind::XMLNAMESPACES_KW, - SyntaxKind::XMLPARSE_KW, - SyntaxKind::XMLPI_KW, - SyntaxKind::XMLROOT_KW, - SyntaxKind::XMLSERIALIZE_KW, - SyntaxKind::XMLTABLE_KW, - SyntaxKind::YES_KW, - SyntaxKind::ZONE_KW, -]); - -pub(crate) const UNRESERVED_KEYWORDS: TokenSet = TokenSet::new(&[ - SyntaxKind::ABORT_KW, - SyntaxKind::ABSENT_KW, - SyntaxKind::ABSOLUTE_KW, - SyntaxKind::ACCESS_KW, - SyntaxKind::ACTION_KW, - SyntaxKind::ADD_KW, - SyntaxKind::ADMIN_KW, - SyntaxKind::AFTER_KW, - SyntaxKind::AGGREGATE_KW, - SyntaxKind::ALSO_KW, - SyntaxKind::ALTER_KW, - SyntaxKind::ALWAYS_KW, - SyntaxKind::ASENSITIVE_KW, - SyntaxKind::ASSERTION_KW, - SyntaxKind::ASSIGNMENT_KW, - SyntaxKind::AT_KW, - SyntaxKind::ATOMIC_KW, - SyntaxKind::ATTACH_KW, - SyntaxKind::ATTRIBUTE_KW, - SyntaxKind::BACKWARD_KW, - SyntaxKind::BEFORE_KW, - SyntaxKind::BEGIN_KW, - SyntaxKind::BREADTH_KW, - SyntaxKind::BY_KW, - SyntaxKind::CACHE_KW, - SyntaxKind::CALL_KW, - SyntaxKind::CALLED_KW, - SyntaxKind::CASCADE_KW, - SyntaxKind::CASCADED_KW, - SyntaxKind::CATALOG_KW, - SyntaxKind::CHAIN_KW, - SyntaxKind::CHARACTERISTICS_KW, - SyntaxKind::CHECKPOINT_KW, - SyntaxKind::CLASS_KW, - SyntaxKind::CLOSE_KW, - SyntaxKind::CLUSTER_KW, - SyntaxKind::COLUMNS_KW, - SyntaxKind::COMMENT_KW, - SyntaxKind::COMMENTS_KW, - SyntaxKind::COMMIT_KW, - SyntaxKind::COMMITTED_KW, - SyntaxKind::COMPRESSION_KW, - SyntaxKind::CONDITIONAL_KW, - SyntaxKind::CONFIGURATION_KW, - SyntaxKind::CONFLICT_KW, - SyntaxKind::CONNECTION_KW, - SyntaxKind::CONSTRAINTS_KW, - SyntaxKind::CONTENT_KW, - SyntaxKind::CONTINUE_KW, - SyntaxKind::CONVERSION_KW, - SyntaxKind::COPY_KW, - SyntaxKind::COST_KW, - SyntaxKind::CSV_KW, - SyntaxKind::CUBE_KW, - SyntaxKind::CURRENT_KW, - SyntaxKind::CURSOR_KW, - SyntaxKind::CYCLE_KW, - SyntaxKind::DATA_KW, - SyntaxKind::DATABASE_KW, - SyntaxKind::DAY_KW, - SyntaxKind::DEALLOCATE_KW, - SyntaxKind::DECLARE_KW, - SyntaxKind::DEFAULTS_KW, - SyntaxKind::DEFERRED_KW, - SyntaxKind::DEFINER_KW, - SyntaxKind::DELETE_KW, - SyntaxKind::DELIMITER_KW, - SyntaxKind::DELIMITERS_KW, - SyntaxKind::DEPENDS_KW, - SyntaxKind::DEPTH_KW, - SyntaxKind::DETACH_KW, - SyntaxKind::DICTIONARY_KW, - SyntaxKind::DISABLE_KW, - SyntaxKind::DISCARD_KW, - SyntaxKind::DOCUMENT_KW, - SyntaxKind::DOMAIN_KW, - SyntaxKind::DOUBLE_KW, - SyntaxKind::DROP_KW, - SyntaxKind::EACH_KW, - SyntaxKind::EMPTY_KW, - SyntaxKind::ENABLE_KW, - SyntaxKind::ENCODING_KW, - SyntaxKind::ENCRYPTED_KW, - SyntaxKind::ENUM_KW, - SyntaxKind::ERROR_KW, - SyntaxKind::ESCAPE_KW, - SyntaxKind::EVENT_KW, - SyntaxKind::EXCLUDE_KW, - SyntaxKind::EXCLUDING_KW, - SyntaxKind::EXCLUSIVE_KW, - SyntaxKind::EXECUTE_KW, - SyntaxKind::EXPLAIN_KW, - SyntaxKind::EXPRESSION_KW, - SyntaxKind::EXTENSION_KW, - SyntaxKind::EXTERNAL_KW, - SyntaxKind::FAMILY_KW, - SyntaxKind::FILTER_KW, - SyntaxKind::FINALIZE_KW, - SyntaxKind::FIRST_KW, - SyntaxKind::FOLLOWING_KW, - SyntaxKind::FORCE_KW, - SyntaxKind::FORMAT_KW, - SyntaxKind::FORWARD_KW, - SyntaxKind::FUNCTION_KW, - SyntaxKind::FUNCTIONS_KW, - SyntaxKind::GENERATED_KW, - SyntaxKind::GLOBAL_KW, - SyntaxKind::GRANTED_KW, - SyntaxKind::GROUPS_KW, - SyntaxKind::HANDLER_KW, - SyntaxKind::HEADER_KW, - SyntaxKind::HOLD_KW, - SyntaxKind::HOUR_KW, - SyntaxKind::IDENTITY_KW, - SyntaxKind::IF_KW, - SyntaxKind::IMMEDIATE_KW, - SyntaxKind::IMMUTABLE_KW, - SyntaxKind::IMPLICIT_KW, - SyntaxKind::IMPORT_KW, - SyntaxKind::INCLUDE_KW, - SyntaxKind::INCLUDING_KW, - SyntaxKind::INCREMENT_KW, - SyntaxKind::INDENT_KW, - SyntaxKind::INDEX_KW, - SyntaxKind::INDEXES_KW, - SyntaxKind::INHERIT_KW, - SyntaxKind::INHERITS_KW, - SyntaxKind::INLINE_KW, - SyntaxKind::INPUT_KW, - SyntaxKind::INSENSITIVE_KW, - SyntaxKind::INSERT_KW, - SyntaxKind::INSTEAD_KW, - SyntaxKind::INVOKER_KW, - SyntaxKind::ISOLATION_KW, - SyntaxKind::KEEP_KW, - SyntaxKind::KEY_KW, - SyntaxKind::KEYS_KW, - SyntaxKind::LABEL_KW, - SyntaxKind::LANGUAGE_KW, - SyntaxKind::LARGE_KW, - SyntaxKind::LAST_KW, - SyntaxKind::LEAKPROOF_KW, - SyntaxKind::LEVEL_KW, - SyntaxKind::LISTEN_KW, - SyntaxKind::LOAD_KW, - SyntaxKind::LOCAL_KW, - SyntaxKind::LOCATION_KW, - SyntaxKind::LOCK_KW, - SyntaxKind::LOCKED_KW, - SyntaxKind::LOGGED_KW, - SyntaxKind::MAPPING_KW, - SyntaxKind::MATCH_KW, - SyntaxKind::MATCHED_KW, - SyntaxKind::MATERIALIZED_KW, - SyntaxKind::MAXVALUE_KW, - SyntaxKind::MERGE_KW, - SyntaxKind::METHOD_KW, - SyntaxKind::MINUTE_KW, - SyntaxKind::MINVALUE_KW, - SyntaxKind::MODE_KW, - SyntaxKind::MONTH_KW, - SyntaxKind::MOVE_KW, - SyntaxKind::NAME_KW, - SyntaxKind::NAMES_KW, - SyntaxKind::NESTED_KW, - SyntaxKind::NEW_KW, - SyntaxKind::NEXT_KW, - SyntaxKind::NFC_KW, - SyntaxKind::NFD_KW, - SyntaxKind::NFKC_KW, - SyntaxKind::NFKD_KW, - SyntaxKind::NO_KW, - SyntaxKind::NORMALIZED_KW, - SyntaxKind::NOTHING_KW, - SyntaxKind::NOTIFY_KW, - SyntaxKind::NOWAIT_KW, - SyntaxKind::NULLS_KW, - SyntaxKind::OBJECT_KW, - SyntaxKind::OF_KW, - SyntaxKind::OFF_KW, - SyntaxKind::OIDS_KW, - SyntaxKind::OLD_KW, - SyntaxKind::OMIT_KW, - SyntaxKind::OPERATOR_KW, - SyntaxKind::OPTION_KW, - SyntaxKind::OPTIONS_KW, - SyntaxKind::ORDINALITY_KW, - SyntaxKind::OTHERS_KW, - SyntaxKind::OVER_KW, - SyntaxKind::OVERRIDING_KW, - SyntaxKind::OWNED_KW, - SyntaxKind::OWNER_KW, - SyntaxKind::PARALLEL_KW, - SyntaxKind::PARAMETER_KW, - SyntaxKind::PARSER_KW, - SyntaxKind::PARTIAL_KW, - SyntaxKind::PARTITION_KW, - SyntaxKind::PASSING_KW, - SyntaxKind::PASSWORD_KW, - SyntaxKind::PATH_KW, - SyntaxKind::PERIOD_KW, - SyntaxKind::PLAN_KW, - SyntaxKind::PLANS_KW, - SyntaxKind::POLICY_KW, - SyntaxKind::PRECEDING_KW, - SyntaxKind::PREPARE_KW, - SyntaxKind::PREPARED_KW, - SyntaxKind::PRESERVE_KW, - SyntaxKind::PRIOR_KW, - SyntaxKind::PRIVILEGES_KW, - SyntaxKind::PROCEDURAL_KW, - SyntaxKind::PROCEDURE_KW, - SyntaxKind::PROCEDURES_KW, - SyntaxKind::PROGRAM_KW, - SyntaxKind::PUBLICATION_KW, - SyntaxKind::QUOTE_KW, - SyntaxKind::QUOTES_KW, - SyntaxKind::RANGE_KW, - SyntaxKind::READ_KW, - SyntaxKind::REASSIGN_KW, - SyntaxKind::RECURSIVE_KW, - SyntaxKind::REF_KW, - SyntaxKind::REFERENCING_KW, - SyntaxKind::REFRESH_KW, - SyntaxKind::REINDEX_KW, - SyntaxKind::RELATIVE_KW, - SyntaxKind::RELEASE_KW, - SyntaxKind::RENAME_KW, - SyntaxKind::REPEATABLE_KW, - SyntaxKind::REPLACE_KW, - SyntaxKind::REPLICA_KW, - SyntaxKind::RESET_KW, - SyntaxKind::RESTART_KW, - SyntaxKind::RESTRICT_KW, - SyntaxKind::RETURN_KW, - SyntaxKind::RETURNS_KW, - SyntaxKind::REVOKE_KW, - SyntaxKind::ROLE_KW, - SyntaxKind::ROLLBACK_KW, - SyntaxKind::ROLLUP_KW, - SyntaxKind::ROUTINE_KW, - SyntaxKind::ROUTINES_KW, - SyntaxKind::ROWS_KW, - SyntaxKind::RULE_KW, - SyntaxKind::SAVEPOINT_KW, - SyntaxKind::SCALAR_KW, - SyntaxKind::SCHEMA_KW, - SyntaxKind::SCHEMAS_KW, - SyntaxKind::SCROLL_KW, - SyntaxKind::SEARCH_KW, - SyntaxKind::SECOND_KW, - SyntaxKind::SECURITY_KW, - SyntaxKind::SEQUENCE_KW, - SyntaxKind::SEQUENCES_KW, - SyntaxKind::SERIALIZABLE_KW, - SyntaxKind::SERVER_KW, - SyntaxKind::SESSION_KW, - SyntaxKind::SET_KW, - SyntaxKind::SETS_KW, - SyntaxKind::SHARE_KW, - SyntaxKind::SHOW_KW, - SyntaxKind::SIMPLE_KW, - SyntaxKind::SKIP_KW, - SyntaxKind::SNAPSHOT_KW, - SyntaxKind::SOURCE_KW, - SyntaxKind::SQL_KW, - SyntaxKind::STABLE_KW, - SyntaxKind::STANDALONE_KW, - SyntaxKind::START_KW, - SyntaxKind::STATEMENT_KW, - SyntaxKind::STATISTICS_KW, - SyntaxKind::STDIN_KW, - SyntaxKind::STDOUT_KW, - SyntaxKind::STORAGE_KW, - SyntaxKind::STORED_KW, - SyntaxKind::STRICT_KW, - SyntaxKind::STRING_KW, - SyntaxKind::STRIP_KW, - SyntaxKind::SUBSCRIPTION_KW, - SyntaxKind::SUPPORT_KW, - SyntaxKind::SYSID_KW, - SyntaxKind::SYSTEM_KW, - SyntaxKind::TABLES_KW, - SyntaxKind::TABLESPACE_KW, - SyntaxKind::TARGET_KW, - SyntaxKind::TEMP_KW, - SyntaxKind::TEMPLATE_KW, - SyntaxKind::TEMPORARY_KW, - SyntaxKind::TEXT_KW, - SyntaxKind::TIES_KW, - SyntaxKind::TRANSACTION_KW, - SyntaxKind::TRANSFORM_KW, - SyntaxKind::TRIGGER_KW, - SyntaxKind::TRUNCATE_KW, - SyntaxKind::TRUSTED_KW, - SyntaxKind::TYPE_KW, - SyntaxKind::TYPES_KW, - SyntaxKind::UESCAPE_KW, - SyntaxKind::UNBOUNDED_KW, - SyntaxKind::UNCOMMITTED_KW, - SyntaxKind::UNCONDITIONAL_KW, - SyntaxKind::UNENCRYPTED_KW, - SyntaxKind::UNKNOWN_KW, - SyntaxKind::UNLISTEN_KW, - SyntaxKind::UNLOGGED_KW, - SyntaxKind::UNTIL_KW, - SyntaxKind::UPDATE_KW, - SyntaxKind::VACUUM_KW, - SyntaxKind::VALID_KW, - SyntaxKind::VALIDATE_KW, - SyntaxKind::VALIDATOR_KW, - SyntaxKind::VALUE_KW, - SyntaxKind::VARYING_KW, - SyntaxKind::VERSION_KW, - SyntaxKind::VIEW_KW, - SyntaxKind::VIEWS_KW, - SyntaxKind::VOLATILE_KW, - SyntaxKind::WHITESPACE_KW, - SyntaxKind::WITHIN_KW, - SyntaxKind::WITHOUT_KW, - SyntaxKind::WORK_KW, - SyntaxKind::WRAPPER_KW, - SyntaxKind::WRITE_KW, - SyntaxKind::XML_KW, - SyntaxKind::YEAR_KW, - SyntaxKind::YES_KW, - SyntaxKind::ZONE_KW, -]); - -pub(crate) const RESERVED_KEYWORDS: TokenSet = TokenSet::new(&[ - SyntaxKind::ALL_KW, - SyntaxKind::ANALYSE_KW, - SyntaxKind::ANALYZE_KW, - SyntaxKind::AND_KW, - SyntaxKind::ANY_KW, - SyntaxKind::ARRAY_KW, - SyntaxKind::AS_KW, - SyntaxKind::ASC_KW, - SyntaxKind::ASYMMETRIC_KW, - SyntaxKind::BOTH_KW, - SyntaxKind::CASE_KW, - SyntaxKind::CAST_KW, - SyntaxKind::CHECK_KW, - SyntaxKind::COLLATE_KW, - SyntaxKind::COLUMN_KW, - SyntaxKind::CONSTRAINT_KW, - SyntaxKind::CREATE_KW, - SyntaxKind::CURRENT_CATALOG_KW, - SyntaxKind::CURRENT_DATE_KW, - SyntaxKind::CURRENT_ROLE_KW, - SyntaxKind::CURRENT_TIME_KW, - SyntaxKind::CURRENT_TIMESTAMP_KW, - SyntaxKind::CURRENT_USER_KW, - SyntaxKind::DEFAULT_KW, - SyntaxKind::DEFERRABLE_KW, - SyntaxKind::DESC_KW, - SyntaxKind::DISTINCT_KW, - SyntaxKind::DO_KW, - SyntaxKind::ELSE_KW, - SyntaxKind::END_KW, - SyntaxKind::EXCEPT_KW, - SyntaxKind::FALSE_KW, - SyntaxKind::FETCH_KW, - SyntaxKind::FOR_KW, - SyntaxKind::FOREIGN_KW, - SyntaxKind::FROM_KW, - SyntaxKind::GRANT_KW, - SyntaxKind::GROUP_KW, - SyntaxKind::HAVING_KW, - SyntaxKind::IN_KW, - SyntaxKind::INITIALLY_KW, - SyntaxKind::INTERSECT_KW, - SyntaxKind::INTO_KW, - SyntaxKind::LATERAL_KW, - SyntaxKind::LEADING_KW, - SyntaxKind::LIMIT_KW, - SyntaxKind::LOCALTIME_KW, - SyntaxKind::LOCALTIMESTAMP_KW, - SyntaxKind::NOT_KW, - SyntaxKind::NULL_KW, - SyntaxKind::OFFSET_KW, - SyntaxKind::ON_KW, - SyntaxKind::ONLY_KW, - SyntaxKind::OR_KW, - SyntaxKind::ORDER_KW, - SyntaxKind::PLACING_KW, - SyntaxKind::PRIMARY_KW, - SyntaxKind::REFERENCES_KW, - SyntaxKind::RETURNING_KW, - SyntaxKind::SELECT_KW, - SyntaxKind::SESSION_USER_KW, - SyntaxKind::SOME_KW, - SyntaxKind::SYMMETRIC_KW, - SyntaxKind::SYSTEM_USER_KW, - SyntaxKind::TABLE_KW, - SyntaxKind::THEN_KW, - SyntaxKind::TO_KW, - SyntaxKind::TRAILING_KW, - SyntaxKind::TRUE_KW, - SyntaxKind::UNION_KW, - SyntaxKind::UNIQUE_KW, - SyntaxKind::USER_KW, - SyntaxKind::USING_KW, - SyntaxKind::VARIADIC_KW, - SyntaxKind::WHEN_KW, - SyntaxKind::WHERE_KW, - SyntaxKind::WINDOW_KW, - SyntaxKind::WITH_KW, -]); - -// Generated TokenSet end diff --git a/crates/squawk_parser/test_data/ok/set_transaction.sql b/crates/squawk_parser/test_data/ok/set_transaction.sql index 4c1b3bb0..430181b5 100644 --- a/crates/squawk_parser/test_data/ok/set_transaction.sql +++ b/crates/squawk_parser/test_data/ok/set_transaction.sql @@ -3,5 +3,8 @@ SET TRANSACTION SNAPSHOT '00000003-0000001B-1'; SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ COMMITTED, read write; -SET TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ WRITE, NOT DEFERRABLE +SET TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ WRITE, NOT DEFERRABLE; + +-- no commas is postgres historical according to gram.y +SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ WRITE NOT DEFERRABLE; diff --git a/crates/squawk_syntax/src/ast.rs b/crates/squawk_syntax/src/ast.rs index 4acbb81b..f73094cf 100644 --- a/crates/squawk_syntax/src/ast.rs +++ b/crates/squawk_syntax/src/ast.rs @@ -24,20 +24,21 @@ // IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. +mod generated; +mod node_ext; mod nodes; mod support; mod traits; -mod node_ext; - use std::marker::PhantomData; use crate::syntax_node::{SyntaxNode, SyntaxNodeChildren, SyntaxToken}; use squawk_parser::SyntaxKind; pub use self::{ - nodes::*, // generated::{nodes::*, tokens::*}, + generated::tokens::*, + nodes::*, // node_ext::{ // AttrKind, FieldKind, Macro, NameLike, NameOrNameRef, PathSegmentKind, SelfParamKind, // SlicePatComponents, StructKind, TraitOrAlias, TypeBoundKind, TypeOrConstParam, @@ -52,7 +53,6 @@ pub use self::{ HasIfNotExists, // HasTypeBounds, // HasVisibility, // HasGenericParams, HasLoopBody, - HasModuleItem, HasName, }, }; diff --git a/crates/squawk_syntax/src/ast/generated/mod.rs b/crates/squawk_syntax/src/ast/generated/mod.rs new file mode 100644 index 00000000..bd37c815 --- /dev/null +++ b/crates/squawk_syntax/src/ast/generated/mod.rs @@ -0,0 +1,2 @@ +pub(crate) mod nodes; +pub(crate) mod tokens; diff --git a/crates/squawk_syntax/src/ast/generated/nodes.rs b/crates/squawk_syntax/src/ast/generated/nodes.rs new file mode 100644 index 00000000..6e8e91db --- /dev/null +++ b/crates/squawk_syntax/src/ast/generated/nodes.rs @@ -0,0 +1,16890 @@ +use crate::ast::AstNode; +use crate::ast::{support, AstChildren}; +use crate::syntax_node::SyntaxNode; +use crate::syntax_node::SyntaxToken; +use crate::SyntaxKind; + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AddColumn { + pub(crate) syntax: SyntaxNode, +} +impl AddColumn { + #[inline] + pub fn add_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ADD_KW) + } + #[inline] + pub fn column_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLUMN_KW) + } + #[inline] + pub fn exists_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXISTS_KW) + } + #[inline] + pub fn if_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IF_KW) + } + #[inline] + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AddConstraint { + pub(crate) syntax: SyntaxNode, +} +impl AddConstraint { + #[inline] + pub fn constraint(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn not_valid(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn add_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ADD_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AddGenerated { + pub(crate) syntax: SyntaxNode, +} +impl AddGenerated { + #[inline] + pub fn add_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ADD_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Alias { + pub(crate) syntax: SyntaxNode, +} +impl Alias { + #[inline] + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterAggregate { + pub(crate) syntax: SyntaxNode, +} +impl AlterAggregate { + #[inline] + pub fn param_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn path(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn aggregate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AGGREGATE_KW) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterAggregateStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterAggregateStmt { + #[inline] + pub fn aggregate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AGGREGATE_KW) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterCollationStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterCollationStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn collation_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLLATION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterColumn { + pub(crate) syntax: SyntaxNode, +} +impl AlterColumn { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn column_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLUMN_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterConstraint { + pub(crate) syntax: SyntaxNode, +} +impl AlterConstraint { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterConversionStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterConversionStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn conversion_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONVERSION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterDatabaseStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterDatabaseStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn database_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DATABASE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterDefaultPrivilegesStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterDefaultPrivilegesStmt { + #[inline] + 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) + } + #[inline] + pub fn privileges_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PRIVILEGES_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterDomain { + pub(crate) syntax: SyntaxNode, +} +impl AlterDomain { + #[inline] + pub fn alter_domain_action(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn path(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn domain_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DOMAIN_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterDomainStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterDomainStmt { + #[inline] + pub fn alter_domain_action(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn domain_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DOMAIN_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterEventTriggerStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterEventTriggerStmt { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn event_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EVENT_KW) + } + #[inline] + pub fn trigger_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIGGER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterExtensionStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterExtensionStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn extension_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXTENSION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterForeignDataWrapperStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterForeignDataWrapperStmt { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_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 wrapper_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WRAPPER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterForeignTableStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterForeignTableStmt { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn foreign_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOREIGN_KW) + } + #[inline] + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterFunctionStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterFunctionStmt { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn function_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FUNCTION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterGroupStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterGroupStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn group_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GROUP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterIndexStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterIndexStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn index_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INDEX_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterLanguageStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterLanguageStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn language_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LANGUAGE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterLargeObjectStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterLargeObjectStmt { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn large_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LARGE_KW) + } + #[inline] + pub fn object_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OBJECT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterMaterializedViewStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterMaterializedViewStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn materialized_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW) + } + #[inline] + pub fn view_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VIEW_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterOperatorClassStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterOperatorClassStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn class_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CLASS_KW) + } + #[inline] + pub fn operator_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPERATOR_KW) + } + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterOperatorFamilyStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterOperatorFamilyStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn family_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FAMILY_KW) + } + #[inline] + pub fn operator_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPERATOR_KW) + } + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterOperatorStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterOperatorStmt { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn operator_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPERATOR_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterPolicyStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterPolicyStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn policy_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::POLICY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterProcedureStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterProcedureStmt { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn procedure_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PROCEDURE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterPublicationStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterPublicationStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn publication_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PUBLICATION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterRoleStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterRoleStmt { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn role_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterRoutineStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterRoutineStmt { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn routine_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROUTINE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterRuleStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterRuleStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn rule_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RULE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterSchemaStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterSchemaStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn rename_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RENAME_KW) + } + #[inline] + pub fn schema_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SCHEMA_KW) + } + #[inline] + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterSequenceStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterSequenceStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn sequence_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEQUENCE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterServerStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterServerStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn server_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SERVER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterStatisticsStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterStatisticsStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn statistics_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STATISTICS_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterSubscriptionStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterSubscriptionStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn subscription_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterSystemStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterSystemStmt { + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } + #[inline] + pub fn system_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SYSTEM_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterTable { + pub(crate) syntax: SyntaxNode, +} +impl AlterTable { + #[inline] + pub fn actions(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn path(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterTablespaceStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterTablespaceStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn tablespace_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLESPACE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterTextSearchConfigurationStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterTextSearchConfigurationStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn configuration_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONFIGURATION_KW) + } + #[inline] + pub fn search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterTextSearchDictionaryStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterTextSearchDictionaryStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn dictionary_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DICTIONARY_KW) + } + #[inline] + pub fn search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterTextSearchParserStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterTextSearchParserStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn parser_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PARSER_KW) + } + #[inline] + pub fn search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterTextSearchTemplateStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterTextSearchTemplateStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn template_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEMPLATE_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterTriggerStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterTriggerStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn trigger_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIGGER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterTypeStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterTypeStmt { + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterUserMappingStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterUserMappingStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) + } + #[inline] + pub fn mapping_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MAPPING_KW) + } + #[inline] + pub fn server_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SERVER_KW) + } + #[inline] + pub fn user_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterUserStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterUserStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn user_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterViewStmt { + pub(crate) syntax: SyntaxNode, +} +impl AlterViewStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn alter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALTER_KW) + } + #[inline] + pub fn view_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VIEW_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AnalyzeStmt { + pub(crate) syntax: SyntaxNode, +} +impl AnalyzeStmt { + #[inline] + pub fn analyze_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ANALYZE_KW) + } + #[inline] + pub fn verbose_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VERBOSE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Arg { + pub(crate) syntax: SyntaxNode, +} +impl Arg { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ArgList { + pub(crate) syntax: SyntaxNode, +} +impl ArgList { + #[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 star_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STAR) + } + #[inline] + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) + } + #[inline] + pub fn distinct_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DISTINCT_KW) + } + #[inline] + pub fn variadic_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VARIADIC_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ArrayExpr { + pub(crate) syntax: SyntaxNode, +} +impl ArrayExpr { + #[inline] + pub fn exprs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn select(&self) -> Option { + support::child(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ConstraintExclusions { + pub(crate) syntax: SyntaxNode, +} +impl ConstraintExclusions { + #[inline] + pub fn exclude_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXCLUDE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ConstraintIncludeClause { + pub(crate) syntax: SyntaxNode, +} +impl ConstraintIncludeClause { + #[inline] + pub fn include_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INCLUDE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ConstraintIndexMethod { + pub(crate) syntax: SyntaxNode, +} +impl ConstraintIndexMethod { + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ConstraintIndexTablespace { + pub(crate) syntax: SyntaxNode, +} +impl ConstraintIndexTablespace { + #[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 tablespace_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLESPACE_KW) + } + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ConstraintOptionList { + pub(crate) syntax: SyntaxNode, +} +impl ConstraintOptionList { + #[inline] + pub fn deferrable_constraint_option(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn initially_deferred_constraint_option( + &self, + ) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn initially_immediate_constraint_option( + &self, + ) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn not_deferrable_constraint_option(&self) -> Option { + support::child(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ConstraintStorageParams { + pub(crate) syntax: SyntaxNode, +} +impl ConstraintStorageParams { + #[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 with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ConstraintWhereClause { + pub(crate) syntax: SyntaxNode, +} +impl ConstraintWhereClause { + #[inline] + pub fn where_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WHERE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CopyStmt { + pub(crate) syntax: SyntaxNode, +} +impl CopyStmt { + #[inline] + pub fn copy_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COPY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CostFuncOption { + pub(crate) syntax: SyntaxNode, +} +impl CostFuncOption { + #[inline] + pub fn cost_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COST_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateAccessMethodStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateAccessMethodStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn access_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ACCESS_KW) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn method_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::METHOD_KW) + } + #[inline] + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateAggregate { + pub(crate) syntax: SyntaxNode, +} +impl CreateAggregate { + #[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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateAggregateStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateAggregateStmt { + #[inline] + pub fn aggregate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AGGREGATE_KW) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateCastStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateCastStmt { + #[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 cast_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CAST_KW) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateCollationStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateCollationStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn collation_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLLATION_KW) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateConversionStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateConversionStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn conversion_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONVERSION_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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateDatabaseStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateDatabaseStmt { + #[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 database_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DATABASE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateDomain { + pub(crate) syntax: SyntaxNode, +} +impl CreateDomain { + #[inline] + pub fn name(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn domain_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DOMAIN_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateDomainStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateDomainStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn domain_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DOMAIN_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateEventTriggerStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateEventTriggerStmt { + #[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 event_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EVENT_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn trigger_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIGGER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateExtensionStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateExtensionStmt { + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn extension_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXTENSION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateForeignDataWrapperStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateForeignDataWrapperStmt { + #[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 wrapper_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WRAPPER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateForeignTableStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateForeignTableStmt { + #[inline] + pub fn if_not_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn foreign_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOREIGN_KW) + } + #[inline] + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateFunc { + pub(crate) syntax: SyntaxNode, +} +impl CreateFunc { + #[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 ret_type(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn function_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FUNCTION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateFunctionStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateFunctionStmt { + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateGroupStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateGroupStmt { + #[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 group_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GROUP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateIndex { + pub(crate) syntax: SyntaxNode, +} +impl CreateIndex { + #[inline] + pub fn if_not_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn concurrently_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn index_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INDEX_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn unique_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNIQUE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateLanguageStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateLanguageStmt { + #[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 language_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LANGUAGE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateMaterializedViewStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateMaterializedViewStmt { + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateOperatorClassStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateOperatorClassStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn class_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CLASS_KW) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn default_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + } + #[inline] + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) + } + #[inline] + pub fn operator_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPERATOR_KW) + } + #[inline] + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) + } + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateOperatorFamilyStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateOperatorFamilyStmt { + #[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 family_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FAMILY_KW) + } + #[inline] + pub fn operator_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPERATOR_KW) + } + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateOperatorStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateOperatorStmt { + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn operator_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPERATOR_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreatePolicyStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreatePolicyStmt { + #[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 on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn policy_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::POLICY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateProcedureStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateProcedureStmt { + #[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 CreatePublicationStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreatePublicationStmt { + #[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 publication_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PUBLICATION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateRoleStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateRoleStmt { + #[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 role_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateRuleStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateRuleStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn rule_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RULE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateSchemaStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateSchemaStmt { + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn schema_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SCHEMA_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateSequenceStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateSequenceStmt { + #[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 sequence_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEQUENCE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateServerStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateServerStmt { + #[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 server_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SERVER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateStatisticsStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateStatisticsStmt { + #[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 statistics_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STATISTICS_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateSubscriptionStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateSubscriptionStmt { + #[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 subscription_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateTable { + pub(crate) syntax: SyntaxNode, +} +impl CreateTable { + #[inline] + pub fn if_not_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn path(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn table_args(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateTableAsStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateTableAsStmt { + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateTablespaceStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateTablespaceStmt { + #[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 tablespace_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLESPACE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateTextSearchConfigurationStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateTextSearchConfigurationStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn configuration_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONFIGURATION_KW) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateTextSearchDictionaryStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateTextSearchDictionaryStmt { + #[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 dictionary_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DICTIONARY_KW) + } + #[inline] + pub fn search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateTextSearchParserStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateTextSearchParserStmt { + #[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 parser_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PARSER_KW) + } + #[inline] + pub fn search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateTextSearchTemplateStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateTextSearchTemplateStmt { + #[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 search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn template_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEMPLATE_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateTransformStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateTransformStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[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 language_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LANGUAGE_KW) + } + #[inline] + pub fn transform_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRANSFORM_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateTriggerStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateTriggerStmt { + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateTypeStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateTypeStmt { + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn create_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CREATE_KW) + } + #[inline] + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateUserMappingStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateUserMappingStmt { + #[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 for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) + } + #[inline] + pub fn mapping_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MAPPING_KW) + } + #[inline] + pub fn server_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SERVER_KW) + } + #[inline] + pub fn user_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateUserStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateUserStmt { + #[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 user_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateViewStmt { + pub(crate) syntax: SyntaxNode, +} +impl CreateViewStmt { + #[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 view_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VIEW_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CustomOp { + pub(crate) syntax: SyntaxNode, +} +impl CustomOp { + #[inline] + pub fn bang_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BANG) + } + #[inline] + pub fn pound_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::POUND) + } + #[inline] + pub fn percent_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PERCENT) + } + #[inline] + pub fn amp_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AMP) + } + #[inline] + pub fn star_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STAR) + } + #[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 l_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_ANGLE) + } + #[inline] + pub fn eq_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EQ) + } + #[inline] + pub fn r_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_ANGLE) + } + #[inline] + pub fn question_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::QUESTION) + } + #[inline] + pub fn at_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AT) + } + #[inline] + pub fn caret_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CARET) + } + #[inline] + pub fn backtick_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BACKTICK) + } + #[inline] + pub fn pipe_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PIPE) + } + #[inline] + pub fn tilde_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TILDE) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DeallocateStmt { + pub(crate) syntax: SyntaxNode, +} +impl DeallocateStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) + } + #[inline] + pub fn deallocate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEALLOCATE_KW) + } + #[inline] + pub fn prepare_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PREPARE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DeclareStmt { + pub(crate) syntax: SyntaxNode, +} +impl DeclareStmt { + #[inline] + pub fn declare_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DECLARE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DefaultConstraint { + pub(crate) syntax: SyntaxNode, +} +impl DefaultConstraint { + #[inline] + 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 Deferrable { + pub(crate) syntax: SyntaxNode, +} +impl Deferrable { + #[inline] + pub fn deferrable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DeferrableConstraintOption { + pub(crate) syntax: SyntaxNode, +} +impl DeferrableConstraintOption { + #[inline] + pub fn deferrable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DeleteStmt { + pub(crate) syntax: SyntaxNode, +} +impl DeleteStmt { + #[inline] + pub fn delete_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DELETE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DetachPartition { + pub(crate) syntax: SyntaxNode, +} +impl DetachPartition { + #[inline] + pub fn detach_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DETACH_KW) + } + #[inline] + pub fn partition_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PARTITION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DisableRls { + pub(crate) syntax: SyntaxNode, +} +impl DisableRls { + #[inline] + pub fn disable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DISABLE_KW) + } + #[inline] + pub fn level_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LEVEL_KW) + } + #[inline] + pub fn row_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROW_KW) + } + #[inline] + pub fn security_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SECURITY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DisableRule { + pub(crate) syntax: SyntaxNode, +} +impl DisableRule { + #[inline] + pub fn disable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DISABLE_KW) + } + #[inline] + pub fn rule_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RULE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DisableTrigger { + pub(crate) syntax: SyntaxNode, +} +impl DisableTrigger { + #[inline] + pub fn disable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DISABLE_KW) + } + #[inline] + pub fn trigger_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIGGER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DiscardStmt { + pub(crate) syntax: SyntaxNode, +} +impl DiscardStmt { + #[inline] + pub fn all_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALL_KW) + } + #[inline] + pub fn discard_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DISCARD_KW) + } + #[inline] + pub fn plans_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PLANS_KW) + } + #[inline] + pub fn sequences_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEQUENCES_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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DistinctClause { + pub(crate) syntax: SyntaxNode, +} +impl DistinctClause { + #[inline] + pub fn distinct_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DISTINCT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DoStmt { + pub(crate) syntax: SyntaxNode, +} +impl DoStmt { + #[inline] + pub fn do_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DO_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DoubleType { + pub(crate) syntax: SyntaxNode, +} +impl DoubleType { + #[inline] + pub fn double_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DOUBLE_KW) + } + #[inline] + pub fn precision_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PRECISION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropAccessMethodStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropAccessMethodStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn access_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ACCESS_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn method_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::METHOD_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropAggregate { + pub(crate) syntax: SyntaxNode, +} +impl DropAggregate { + #[inline] + pub fn aggregates(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn aggregate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AGGREGATE_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropCastStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropCastStmt { + #[inline] + pub fn if_exists(&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 cast_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CAST_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropCollationStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropCollationStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn collation_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLLATION_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropColumn { + pub(crate) syntax: SyntaxNode, +} +impl DropColumn { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn column_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLUMN_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropConstraint { + pub(crate) syntax: SyntaxNode, +} +impl DropConstraint { + #[inline] + pub fn constraint(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + 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) + } + #[inline] + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropConversionStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropConversionStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn conversion_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONVERSION_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropDatabase { + pub(crate) syntax: SyntaxNode, +} +impl DropDatabase { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn database_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DATABASE_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropDatabaseStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropDatabaseStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn database_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DATABASE_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropDefault { + pub(crate) syntax: SyntaxNode, +} +impl DropDefault { + #[inline] + pub fn default_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropDomainStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropDomainStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn types(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn domain_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DOMAIN_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropEventTriggerStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropEventTriggerStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn event_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EVENT_KW) + } + #[inline] + pub fn trigger_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIGGER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropExpression { + pub(crate) syntax: SyntaxNode, +} +impl DropExpression { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn expression_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXPRESSION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropExtensionStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropExtensionStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_refs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn extension_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXTENSION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropForeignDataWrapperStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropForeignDataWrapperStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn data_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DATA_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn foreign_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOREIGN_KW) + } + #[inline] + pub fn wrapper_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WRAPPER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropForeignTableStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropForeignTableStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn foreign_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOREIGN_KW) + } + #[inline] + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropFunctionStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropFunctionStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn function_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FUNCTION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropGroupStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropGroupStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn group_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GROUP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropIdentity { + pub(crate) syntax: SyntaxNode, +} +impl DropIdentity { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn identity_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENTITY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropIndex { + pub(crate) syntax: SyntaxNode, +} +impl DropIndex { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn paths(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn concurrently_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn index_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INDEX_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropIndexStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropIndexStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn concurrently_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn index_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INDEX_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropLanguageStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropLanguageStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn language_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LANGUAGE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropMaterializedViewStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropMaterializedViewStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn materialized_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW) + } + #[inline] + pub fn view_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VIEW_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropNotNull { + pub(crate) syntax: SyntaxNode, +} +impl DropNotNull { + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropOperatorClassStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropOperatorClassStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn class_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CLASS_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn operator_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPERATOR_KW) + } + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropOperatorFamilyStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropOperatorFamilyStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn family_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FAMILY_KW) + } + #[inline] + pub fn operator_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPERATOR_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropOperatorStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropOperatorStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn operator_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OPERATOR_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropOwnedStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropOwnedStmt { + #[inline] + pub fn by_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BY_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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropPolicyStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropPolicyStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn policy_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::POLICY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropProcedureStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropProcedureStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn procedure_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PROCEDURE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropPublicationStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropPublicationStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_refs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn publication_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PUBLICATION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropRoleStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropRoleStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_refs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn role_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropRoutineStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropRoutineStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn routine_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROUTINE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropRuleStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropRuleStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn rule_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RULE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropSchemaStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropSchemaStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn schema_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SCHEMA_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropSequenceStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropSequenceStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_refs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn sequence_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEQUENCE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropServerStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropServerStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn server_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SERVER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropStatisticsStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropStatisticsStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn statistics_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STATISTICS_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropSubscriptionStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropSubscriptionStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn subscription_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropTable { + pub(crate) syntax: SyntaxNode, +} +impl DropTable { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn path(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn comma_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMA) + } + #[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) + } + #[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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropTablespaceStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropTablespaceStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn tablespace_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLESPACE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropTextSearchConfigStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropTextSearchConfigStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn configuration_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONFIGURATION_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropTextSearchDictStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropTextSearchDictStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn dictionary_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DICTIONARY_KW) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropTextSearchParserStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropTextSearchParserStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn parser_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PARSER_KW) + } + #[inline] + pub fn search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropTextSearchTemplateStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropTextSearchTemplateStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn search_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SEARCH_KW) + } + #[inline] + pub fn template_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEMPLATE_KW) + } + #[inline] + pub fn text_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TEXT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropTransformStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropTransformStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn transform_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRANSFORM_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropTriggerStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropTriggerStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn on_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ON_KW) + } + #[inline] + pub fn trigger_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIGGER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropType { + pub(crate) syntax: SyntaxNode, +} +impl DropType { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn paths(&self) -> AstChildren { + support::children(&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) + } + #[inline] + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + } + #[inline] + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropTypeStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropTypeStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropUserMappingStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropUserMappingStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) + } + #[inline] + pub fn mapping_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MAPPING_KW) + } + #[inline] + pub fn server_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SERVER_KW) + } + #[inline] + pub fn user_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropUserStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropUserStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_refs(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn user_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropViewStmt { + pub(crate) syntax: SyntaxNode, +} +impl DropViewStmt { + #[inline] + pub fn if_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn drop_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DROP_KW) + } + #[inline] + pub fn view_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VIEW_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct EnableAlwaysRule { + pub(crate) syntax: SyntaxNode, +} +impl EnableAlwaysRule { + #[inline] + pub fn always_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALWAYS_KW) + } + #[inline] + pub fn enable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ENABLE_KW) + } + #[inline] + pub fn rule_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RULE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct EnableAlwaysTrigger { + pub(crate) syntax: SyntaxNode, +} +impl EnableAlwaysTrigger { + #[inline] + pub fn always_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALWAYS_KW) + } + #[inline] + pub fn enable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ENABLE_KW) + } + #[inline] + pub fn trigger_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIGGER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct EnableReplicaRule { + pub(crate) syntax: SyntaxNode, +} +impl EnableReplicaRule { + #[inline] + pub fn enable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ENABLE_KW) + } + #[inline] + pub fn replica_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REPLICA_KW) + } + #[inline] + pub fn rule_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RULE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct EnableReplicaTrigger { + pub(crate) syntax: SyntaxNode, +} +impl EnableReplicaTrigger { + #[inline] + pub fn enable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ENABLE_KW) + } + #[inline] + pub fn replica_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REPLICA_KW) + } + #[inline] + pub fn trigger_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIGGER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct EnableRls { + pub(crate) syntax: SyntaxNode, +} +impl EnableRls { + #[inline] + pub fn enable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ENABLE_KW) + } + #[inline] + pub fn level_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LEVEL_KW) + } + #[inline] + pub fn row_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROW_KW) + } + #[inline] + pub fn security_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SECURITY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct EnableRule { + pub(crate) syntax: SyntaxNode, +} +impl EnableRule { + #[inline] + pub fn enable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ENABLE_KW) + } + #[inline] + pub fn rule_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RULE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct EnableTrigger { + pub(crate) syntax: SyntaxNode, +} +impl EnableTrigger { + #[inline] + pub fn enable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ENABLE_KW) + } + #[inline] + pub fn trigger_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRIGGER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExcludeConstraint { + pub(crate) syntax: SyntaxNode, +} +impl ExcludeConstraint { + #[inline] + pub fn exclude_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXCLUDE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExecuteStmt { + pub(crate) syntax: SyntaxNode, +} +impl ExecuteStmt { + #[inline] + pub fn execute_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXECUTE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExplainStmt { + pub(crate) syntax: SyntaxNode, +} +impl ExplainStmt { + #[inline] + pub fn explain_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXPLAIN_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FatArrow { + pub(crate) syntax: SyntaxNode, +} +impl FatArrow { + #[inline] + pub fn eq_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EQ) + } + #[inline] + pub fn r_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_ANGLE) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FetchStmt { + pub(crate) syntax: SyntaxNode, +} +impl FetchStmt { + #[inline] + pub fn fetch_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FETCH_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FieldExpr { + pub(crate) syntax: SyntaxNode, +} +impl FieldExpr { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[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 dot_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DOT) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FilterClause { + pub(crate) syntax: SyntaxNode, +} +impl FilterClause { + #[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 filter_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FILTER_KW) + } + #[inline] + pub fn where_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WHERE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ForceRls { + pub(crate) syntax: SyntaxNode, +} +impl ForceRls { + #[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) + } + #[inline] + pub fn row_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROW_KW) + } + #[inline] + pub fn security_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SECURITY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ForeignKeyConstraint { + pub(crate) syntax: SyntaxNode, +} +impl ForeignKeyConstraint { + #[inline] + pub fn column_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn path(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn foreign_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOREIGN_KW) + } + #[inline] + pub fn full_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FULL_KW) + } + #[inline] + pub fn key_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::KEY_KW) + } + #[inline] + pub fn match_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATCH_KW) + } + #[inline] + pub fn partial_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PARTIAL_KW) + } + #[inline] + pub fn references_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REFERENCES_KW) + } + #[inline] + pub fn simple_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SIMPLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FromClause { + pub(crate) syntax: SyntaxNode, +} +impl FromClause { + #[inline] + pub fn from_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FROM_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FuncOptionList { + pub(crate) syntax: SyntaxNode, +} +impl FuncOptionList { + #[inline] + pub fn options(&self) -> AstChildren { + support::children(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct GeneratedConstraint { + pub(crate) syntax: SyntaxNode, +} +impl GeneratedConstraint { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn sequence_option_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 always_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ALWAYS_KW) + } + #[inline] + pub fn as_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AS_KW) + } + #[inline] + pub fn by_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BY_KW) + } + #[inline] + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + } + #[inline] + pub fn default_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFAULT_KW) + } + #[inline] + pub fn generated_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GENERATED_KW) + } + #[inline] + pub fn identity_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENTITY_KW) + } + #[inline] + pub fn stored_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STORED_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct GrantStmt { + pub(crate) syntax: SyntaxNode, +} +impl GrantStmt { + #[inline] + pub fn grant_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GRANT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct GroupByClause { + pub(crate) syntax: SyntaxNode, +} +impl GroupByClause { + #[inline] + pub fn group_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::GROUP_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Gteq { + pub(crate) syntax: SyntaxNode, +} +impl Gteq { + #[inline] + pub fn eq_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EQ) + } + #[inline] + pub fn r_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_ANGLE) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct HavingClause { + pub(crate) syntax: SyntaxNode, +} +impl HavingClause { + #[inline] + pub fn having_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::HAVING_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IfExists { + pub(crate) syntax: SyntaxNode, +} +impl IfExists { + #[inline] + pub fn exists_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXISTS_KW) + } + #[inline] + pub fn if_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IF_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IfNotExists { + pub(crate) syntax: SyntaxNode, +} +impl IfNotExists { + #[inline] + pub fn exists_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXISTS_KW) + } + #[inline] + pub fn if_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IF_KW) + } + #[inline] + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ImportForeignSchema { + pub(crate) syntax: SyntaxNode, +} +impl ImportForeignSchema { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn foreign_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOREIGN_KW) + } + #[inline] + pub fn import_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IMPORT_KW) + } + #[inline] + pub fn schema_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SCHEMA_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IndexExpr { + pub(crate) syntax: SyntaxNode, +} +impl IndexExpr { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn l_brack_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_BRACK) + } + #[inline] + pub fn r_brack_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_BRACK) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IndexParams { + pub(crate) syntax: SyntaxNode, +} +impl IndexParams { + #[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 Inherit { + pub(crate) syntax: SyntaxNode, +} +impl Inherit { + #[inline] + pub fn inherit_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INHERIT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct InitiallyDeferredConstraintOption { + pub(crate) syntax: SyntaxNode, +} +impl InitiallyDeferredConstraintOption { + #[inline] + pub fn deferred_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFERRED_KW) + } + #[inline] + pub fn initially_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INITIALLY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct InitiallyImmediateConstraintOption { + pub(crate) syntax: SyntaxNode, +} +impl InitiallyImmediateConstraintOption { + #[inline] + pub fn immediate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IMMEDIATE_KW) + } + #[inline] + pub fn initially_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INITIALLY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct InsertStmt { + pub(crate) syntax: SyntaxNode, +} +impl InsertStmt { + #[inline] + pub fn insert_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INSERT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IntervalType { + pub(crate) syntax: SyntaxNode, +} +impl IntervalType { + #[inline] + pub fn literal(&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 hour_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::HOUR_KW) + } + #[inline] + pub fn interval_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INTERVAL_KW) + } + #[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 to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_KW) + } + #[inline] + pub fn year_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::YEAR_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IntoClause { + pub(crate) syntax: SyntaxNode, +} +impl IntoClause { + #[inline] + pub fn into_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INTO_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IsDistinctFrom { + pub(crate) syntax: SyntaxNode, +} +impl IsDistinctFrom { + #[inline] + pub fn distinct_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DISTINCT_KW) + } + #[inline] + pub fn from_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FROM_KW) + } + #[inline] + pub fn is_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IS_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IsNot { + pub(crate) syntax: SyntaxNode, +} +impl IsNot { + #[inline] + pub fn is_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IS_KW) + } + #[inline] + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IsNotDistinctFrom { + pub(crate) syntax: SyntaxNode, +} +impl IsNotDistinctFrom { + #[inline] + pub fn distinct_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DISTINCT_KW) + } + #[inline] + pub fn from_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FROM_KW) + } + #[inline] + pub fn is_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IS_KW) + } + #[inline] + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IsNull { + pub(crate) syntax: SyntaxNode, +} +impl IsNull { + #[inline] + pub fn is_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IS_KW) + } + #[inline] + pub fn null_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULL_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Join { + pub(crate) syntax: SyntaxNode, +} +impl Join { + #[inline] + pub fn cross_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CROSS_KW) + } + #[inline] + pub fn full_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FULL_KW) + } + #[inline] + pub fn inner_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INNER_KW) + } + #[inline] + pub fn join_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::JOIN_KW) + } + #[inline] + pub fn left_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LEFT_KW) + } + #[inline] + pub fn natural_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NATURAL_KW) + } + #[inline] + pub fn outer_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OUTER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct JsonBehaviorClause { + pub(crate) syntax: SyntaxNode, +} +impl JsonBehaviorClause { + #[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 empty_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EMPTY_KW) + } + #[inline] + pub fn error_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ERROR_KW) + } + #[inline] + 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 JsonFormatClause { + pub(crate) syntax: SyntaxNode, +} +impl JsonFormatClause { + #[inline] + pub fn name(&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(crate) syntax: SyntaxNode, +} +impl JsonKeyValue { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + 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 JsonKeysUniqueClause { + pub(crate) syntax: SyntaxNode, +} +impl JsonKeysUniqueClause { + #[inline] + pub fn keys_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::KEYS_KW) + } + #[inline] + pub fn unique_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNIQUE_KW) + } + #[inline] + 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 JsonNullClause { + pub(crate) syntax: SyntaxNode, +} +impl JsonNullClause { + #[inline] + pub fn absent_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ABSENT_KW) + } + #[inline] + 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 JsonOnErrorClause { + pub(crate) syntax: SyntaxNode, +} +impl JsonOnErrorClause { + #[inline] + pub fn empty_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EMPTY_KW) + } + #[inline] + pub fn error_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ERROR_KW) + } + #[inline] + 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 JsonPassingClause { + pub(crate) syntax: SyntaxNode, +} +impl JsonPassingClause { + #[inline] + pub fn named_args(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn passing_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PASSING_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct JsonQuotesClause { + pub(crate) syntax: SyntaxNode, +} +impl JsonQuotesClause { + #[inline] + pub fn keep_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::KEEP_KW) + } + #[inline] + pub fn omit_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OMIT_KW) + } + #[inline] + pub fn quotes_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::QUOTES_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct JsonReturningClause { + pub(crate) syntax: SyntaxNode, +} +impl JsonReturningClause { + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn returning_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RETURNING_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct JsonValueExpr { + pub(crate) syntax: SyntaxNode, +} +impl JsonValueExpr { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn json_format_clause(&self) -> Option { + support::child(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct JsonWrapperBehaviorClause { + pub(crate) syntax: SyntaxNode, +} +impl JsonWrapperBehaviorClause { + #[inline] + pub fn conditional_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONDITIONAL_KW) + } + #[inline] + 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) + } + #[inline] + pub fn wrapper_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WRAPPER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LanguageFuncOption { + pub(crate) syntax: SyntaxNode, +} +impl LanguageFuncOption { + #[inline] + pub fn name_ref(&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(crate) syntax: SyntaxNode, +} +impl LeakproofFuncOption { + #[inline] + pub fn leakproof_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LEAKPROOF_KW) + } + #[inline] + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LikeClause { + pub(crate) syntax: SyntaxNode, +} +impl LikeClause { + #[inline] + pub fn like_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LIKE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LimitClause { + pub(crate) syntax: SyntaxNode, +} +impl LimitClause { + #[inline] + pub fn limit_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LIMIT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ListenStmt { + pub(crate) syntax: SyntaxNode, +} +impl ListenStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn listen_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LISTEN_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Literal { + pub(crate) syntax: SyntaxNode, +} +impl Literal {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LoadStmt { + pub(crate) syntax: SyntaxNode, +} +impl LoadStmt { + #[inline] + pub fn load_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LOAD_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LockStmt { + pub(crate) syntax: SyntaxNode, +} +impl LockStmt { + #[inline] + 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 LockingClause { + pub(crate) syntax: SyntaxNode, +} +impl LockingClause { + #[inline] + pub fn for_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FOR_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Lteq { + pub(crate) syntax: SyntaxNode, +} +impl Lteq { + #[inline] + pub fn l_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_ANGLE) + } + #[inline] + pub fn eq_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EQ) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MergeStmt { + pub(crate) syntax: SyntaxNode, +} +impl MergeStmt { + #[inline] + pub fn merge_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MERGE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MoveStmt { + pub(crate) syntax: SyntaxNode, +} +impl MoveStmt { + #[inline] + pub fn move_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MOVE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Name { + pub(crate) syntax: SyntaxNode, +} +impl Name { + #[inline] + pub fn ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) + } +} + +#[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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NamedArg { + pub(crate) syntax: SyntaxNode, +} +impl NamedArg { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn fat_arrow(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + 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 bang_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::BANG) + } + #[inline] + 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 l_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_ANGLE) + } + #[inline] + pub fn r_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_ANGLE) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NoForceRls { + 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) + } + #[inline] + pub fn no_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NO_KW) + } + #[inline] + pub fn row_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROW_KW) + } + #[inline] + 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 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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NotDeferrable { + pub(crate) syntax: SyntaxNode, +} +impl NotDeferrable { + #[inline] + pub fn deferrable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW) + } + #[inline] + 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 deferrable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFERRABLE_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 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 not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NotNullConstraint { + pub(crate) syntax: SyntaxNode, +} +impl NotNullConstraint { + #[inline] + pub fn 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 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) + } +} + +#[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) + } + #[inline] + pub fn of_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OF_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NotValid { + pub(crate) syntax: SyntaxNode, +} +impl NotValid { + #[inline] + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) + } + #[inline] + pub fn valid_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VALID_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NotifyStmt { + pub(crate) syntax: SyntaxNode, +} +impl NotifyStmt { + #[inline] + pub fn notify_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOTIFY_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) + } + #[inline] + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + } + #[inline] + pub fn null_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULL_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) + } + #[inline] + pub fn of_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OF_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct OffsetClause { + pub(crate) syntax: SyntaxNode, +} +impl OffsetClause { + #[inline] + pub fn offset_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OFFSET_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Op { + pub(crate) syntax: SyntaxNode, +} +impl Op { + #[inline] + pub fn at_time_zone(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn colon_colon(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn colon_eq(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn custom_op(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn fat_arrow(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn gteq(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn is_distinct_from(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn is_not(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn is_not_distinct_from(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn lteq(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn neq(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn neqb(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn not_in(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn not_like(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn operator_call(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn similar_to(&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) + } + #[inline] + pub fn l_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_ANGLE) + } + #[inline] + pub fn eq_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EQ) + } + #[inline] + pub fn r_angle_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_ANGLE) + } + #[inline] + pub fn caret_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CARET) + } + #[inline] + pub fn and_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AND_KW) + } + #[inline] + pub fn collate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLLATE_KW) + } + #[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) + } + #[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) + } + #[inline] + pub fn overlaps_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OVERLAPS_KW) + } + #[inline] + pub fn value_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VALUE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct OperatorCall { + pub(crate) syntax: SyntaxNode, +} +impl OperatorCall { + #[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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct OrReplace { + pub(crate) syntax: SyntaxNode, +} +impl OrReplace { + #[inline] + pub fn or_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OR_KW) + } + #[inline] + pub fn replace_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REPLACE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct OrderByClause { + pub(crate) syntax: SyntaxNode, +} +impl OrderByClause { + #[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) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } + #[inline] + pub fn over_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OVER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct OwnerTo { + pub(crate) syntax: SyntaxNode, +} +impl OwnerTo { + #[inline] + pub fn role(&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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ParallelFuncOption { + pub(crate) syntax: SyntaxNode, +} +impl ParallelFuncOption { + #[inline] + pub fn parallel_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PARALLEL_KW) + } + #[inline] + pub fn restricted_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICTED_KW) + } + #[inline] + pub fn safe_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SAFE_KW) + } + #[inline] + pub fn unsafe_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNSAFE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Param { + pub(crate) syntax: SyntaxNode, +} +impl Param { + #[inline] + pub fn mode(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn param_default(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ParamDefault { + pub(crate) syntax: SyntaxNode, +} +impl ParamDefault { + #[inline] + pub fn expr(&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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ParamIn { + pub(crate) syntax: SyntaxNode, +} +impl ParamIn { + #[inline] + pub fn in_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IN_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ParamInOut { + pub(crate) syntax: SyntaxNode, +} +impl ParamInOut { + #[inline] + pub fn in_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IN_KW) + } + #[inline] + pub fn inout_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INOUT_KW) + } + #[inline] + pub fn out_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::OUT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ParamList { + pub(crate) syntax: SyntaxNode, +} +impl ParamList { + #[inline] + pub fn params(&self) -> AstChildren { + support::children(&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) + } +} + +#[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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ParenExpr { + pub(crate) syntax: SyntaxNode, +} +impl ParenExpr { + #[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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Path { + pub(crate) syntax: SyntaxNode, +} +impl Path { + #[inline] + pub fn qualifier(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn segment(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn dot_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DOT) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PathSegment { + pub(crate) syntax: SyntaxNode, +} +impl PathSegment { + #[inline] + pub fn name(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PathType { + pub(crate) syntax: SyntaxNode, +} +impl PathType { + #[inline] + pub fn arg_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn path(&self) -> Option { + support::child(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PercentType { + pub(crate) syntax: SyntaxNode, +} +impl PercentType { + #[inline] + pub fn percent_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PERCENT) + } + #[inline] + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PercentTypeClause { + pub(crate) syntax: SyntaxNode, +} +impl PercentTypeClause { + #[inline] + pub fn percent_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PERCENT) + } + #[inline] + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PostfixExpr { + pub(crate) syntax: SyntaxNode, +} +impl PostfixExpr { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PrefixExpr { + pub(crate) syntax: SyntaxNode, +} +impl PrefixExpr { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PrepareStmt { + pub(crate) syntax: SyntaxNode, +} +impl PrepareStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn prepare_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PREPARE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PrepareTransactionStmt { + pub(crate) syntax: SyntaxNode, +} +impl PrepareTransactionStmt { + #[inline] + pub fn literal(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + 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 PrimaryKeyConstraint { + pub(crate) syntax: SyntaxNode, +} +impl PrimaryKeyConstraint { + #[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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ReadCommitted { + pub(crate) syntax: SyntaxNode, +} +impl ReadCommitted { + #[inline] + pub fn committed_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMMITTED_KW) + } + #[inline] + 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 only_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ONLY_KW) + } + #[inline] + 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 read_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::READ_KW) + } + #[inline] + pub fn uncommitted_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNCOMMITTED_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ReadWrite { + pub(crate) syntax: SyntaxNode, +} +impl ReadWrite { + #[inline] + pub fn 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 ReassignStmt { + pub(crate) syntax: SyntaxNode, +} +impl ReassignStmt { + #[inline] + pub fn reassign_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REASSIGN_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ReferencesConstraint { + pub(crate) syntax: SyntaxNode, +} +impl ReferencesConstraint { + #[inline] + pub fn name_ref(&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 constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + } + #[inline] + pub fn full_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::FULL_KW) + } + #[inline] + pub fn match_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATCH_KW) + } + #[inline] + pub fn partial_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PARTIAL_KW) + } + #[inline] + pub fn references_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REFERENCES_KW) + } + #[inline] + pub fn simple_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SIMPLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RefreshStmt { + pub(crate) syntax: SyntaxNode, +} +impl RefreshStmt { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn concurrently_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW) + } + #[inline] + pub fn data_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DATA_KW) + } + #[inline] + pub fn materialized_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW) + } + #[inline] + pub fn refresh_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REFRESH_KW) + } + #[inline] + pub fn view_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VIEW_KW) + } + #[inline] + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ReindexStmt { + pub(crate) syntax: SyntaxNode, +} +impl ReindexStmt { + #[inline] + pub fn reindex_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REINDEX_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RelationName { + pub(crate) syntax: SyntaxNode, +} +impl RelationName { + #[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 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 ReleaseSavepointStmt { + pub(crate) syntax: SyntaxNode, +} +impl ReleaseSavepointStmt { + #[inline] + pub fn name_ref(&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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RenameColumn { + pub(crate) syntax: SyntaxNode, +} +impl RenameColumn { + #[inline] + pub fn column_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COLUMN_KW) + } + #[inline] + pub fn rename_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RENAME_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RenameConstraint { + 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) + } + #[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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RenameTable { + pub(crate) syntax: SyntaxNode, +} +impl RenameTable { + #[inline] + pub fn name_ref(&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) + } +} + +#[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 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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RepeatableRead { + pub(crate) syntax: SyntaxNode, +} +impl RepeatableRead { + #[inline] + pub fn read_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::READ_KW) + } + #[inline] + 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 identity_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENTITY_KW) + } + #[inline] + pub fn replica_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REPLICA_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ResetFuncOption { + pub(crate) syntax: SyntaxNode, +} +impl ResetFuncOption { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + 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 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 reset_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESET_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ResetStmt { + pub(crate) syntax: SyntaxNode, +} +impl ResetStmt { + #[inline] + pub fn name_ref(&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 ResetStorageParams { + pub(crate) syntax: SyntaxNode, +} +impl ResetStorageParams { + #[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 reset_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESET_KW) + } +} + +#[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) + } + #[inline] + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RetType { + pub(crate) syntax: SyntaxNode, +} +impl RetType { + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[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 RevokeStmt { + pub(crate) syntax: SyntaxNode, +} +impl RevokeStmt { + #[inline] + pub fn revoke_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::REVOKE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Role { + pub(crate) syntax: SyntaxNode, +} +impl Role { + #[inline] + pub fn current_role_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CURRENT_ROLE_KW) + } + #[inline] + 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 ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) + } + #[inline] + pub fn session_user_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SESSION_USER_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Rollback { + pub(crate) syntax: SyntaxNode, +} +impl Rollback { + #[inline] + pub fn abort_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ABORT_KW) + } + #[inline] + pub fn rollback_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROLLBACK_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RollbackStmt { + pub(crate) syntax: SyntaxNode, +} +impl RollbackStmt { + #[inline] + pub fn rollback_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROLLBACK_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RowsFuncOption { + pub(crate) syntax: SyntaxNode, +} +impl RowsFuncOption { + #[inline] + pub fn rows_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROWS_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SavepointStmt { + pub(crate) syntax: SyntaxNode, +} +impl SavepointStmt { + #[inline] + pub fn savepoint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SecurityFuncOption { + pub(crate) syntax: SyntaxNode, +} +impl SecurityFuncOption { + #[inline] + pub fn definer_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DEFINER_KW) + } + #[inline] + pub fn invoker_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INVOKER_KW) + } + #[inline] + pub fn security_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SECURITY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SecurityLabelStmt { + pub(crate) syntax: SyntaxNode, +} +impl SecurityLabelStmt { + #[inline] + pub fn label_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LABEL_KW) + } + #[inline] + pub fn security_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SECURITY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Select { + pub(crate) syntax: SyntaxNode, +} +impl Select { + #[inline] + pub fn select_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SELECT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SelectClause { + pub(crate) syntax: SyntaxNode, +} +impl SelectClause { + #[inline] + pub fn select_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SELECT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SelectIntoStmt { + pub(crate) syntax: SyntaxNode, +} +impl SelectIntoStmt { + #[inline] + pub fn select_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SELECT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SequenceOptionList { + pub(crate) syntax: SyntaxNode, +} +impl SequenceOptionList { + #[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 Serializable { + pub(crate) syntax: SyntaxNode, +} +impl Serializable { + #[inline] + pub fn serializable_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SERIALIZABLE_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) + } + #[inline] + 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 SetCompression { + pub(crate) syntax: SyntaxNode, +} +impl SetCompression { + #[inline] + pub fn compression_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::COMPRESSION_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetConstraintsStmt { + pub(crate) syntax: SyntaxNode, +} +impl SetConstraintsStmt { + #[inline] + pub fn constraints_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINTS_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetDefault { + pub(crate) syntax: SyntaxNode, +} +impl SetDefault { + #[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 set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_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) + } + #[inline] + pub fn expression_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::EXPRESSION_KW) + } + #[inline] + 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 set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetGenerated { + pub(crate) syntax: SyntaxNode, +} +impl SetGenerated { + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetGeneratedOptions { + pub(crate) syntax: SyntaxNode, +} +impl SetGeneratedOptions { + #[inline] + pub fn 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 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 SetNotNull { + pub(crate) syntax: SyntaxNode, +} +impl SetNotNull { + #[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 set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetOptions { + pub(crate) syntax: SyntaxNode, +} +impl SetOptions { + #[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 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 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 set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetRoleStmt { + pub(crate) syntax: SyntaxNode, +} +impl SetRoleStmt { + #[inline] + pub fn role_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ROLE_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_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) + } + #[inline] + pub fn schema_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SCHEMA_KW) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetSessionAuthStmt { + pub(crate) syntax: SyntaxNode, +} +impl SetSessionAuthStmt { + #[inline] + pub fn authorization_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::AUTHORIZATION_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) + } +} + +#[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) + } + #[inline] + pub fn statistics_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STATISTICS_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetStmt { + pub(crate) syntax: SyntaxNode, +} +impl SetStmt { + #[inline] + pub fn set_options(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_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) + } + #[inline] + pub fn storage_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STORAGE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetStorageParams { + pub(crate) syntax: SyntaxNode, +} +impl SetStorageParams { + #[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 set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetTablespace { + pub(crate) syntax: SyntaxNode, +} +impl SetTablespace { + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } + #[inline] + pub fn tablespace_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLESPACE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetTransactionStmt { + pub(crate) syntax: SyntaxNode, +} +impl SetTransactionStmt { + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } + #[inline] + pub fn transaction_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRANSACTION_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetType { + pub(crate) syntax: SyntaxNode, +} +impl SetType { + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SetUnlogged { + pub(crate) syntax: SyntaxNode, +} +impl SetUnlogged { + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } + #[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) + } + #[inline] + pub fn without_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITHOUT_KW) + } +} + +#[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) + } + #[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 ShowStmt { + pub(crate) syntax: SyntaxNode, +} +impl ShowStmt { + #[inline] + pub fn show_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SHOW_KW) + } +} + +#[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) + } + #[inline] + pub fn to_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TO_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) + } +} + +#[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) + } + #[inline] + pub fn input_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::INPUT_KW) + } + #[inline] + 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 SupportFuncOption { + pub(crate) syntax: SyntaxNode, +} +impl SupportFuncOption { + #[inline] + pub fn support_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SUPPORT_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TableArgs { + pub(crate) syntax: SyntaxNode, +} +impl TableArgs { + #[inline] + pub fn table_arg(&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) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TableList { + pub(crate) syntax: SyntaxNode, +} +impl TableList { + #[inline] + pub fn relation_names(&self) -> AstChildren { + support::children(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TableStmt { + pub(crate) syntax: SyntaxNode, +} +impl TableStmt { + #[inline] + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Target { + pub(crate) syntax: SyntaxNode, +} +impl Target { + #[inline] + pub fn expr(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn star_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::STAR) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TargetList { + pub(crate) syntax: SyntaxNode, +} +impl TargetList { + #[inline] + pub fn targets(&self) -> AstChildren { + support::children(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TimeType { + pub(crate) syntax: SyntaxNode, +} +impl TimeType { + #[inline] + pub fn literal(&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 time_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TIME_KW) + } + #[inline] + pub fn timestamp_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TIMESTAMP_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 TransactionModeIsolationLevel { + pub(crate) syntax: SyntaxNode, +} +impl TransactionModeIsolationLevel { + #[inline] + pub fn read_committed(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn read_uncommitted(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn repeatable_read(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn serializable(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn isolation_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::ISOLATION_KW) + } + #[inline] + pub fn level_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::LEVEL_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TransactionModeList { + pub(crate) syntax: SyntaxNode, +} +impl TransactionModeList { + #[inline] + pub fn transaction_modes(&self) -> AstChildren { + support::children(&self.syntax) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TransformFuncOption { + pub(crate) syntax: SyntaxNode, +} +impl TransformFuncOption { + #[inline] + pub fn transform_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRANSFORM_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TruncateStmt { + pub(crate) syntax: SyntaxNode, +} +impl TruncateStmt { + #[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 struct TupleExpr { + pub(crate) syntax: SyntaxNode, +} +impl TupleExpr { + #[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 UniqueConstraint { + pub(crate) syntax: SyntaxNode, +} +impl UniqueConstraint { + #[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 unique_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UNIQUE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct UnlistenStmt { + pub(crate) syntax: SyntaxNode, +} +impl UnlistenStmt { + #[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 struct UpdateStmt { + pub(crate) syntax: SyntaxNode, +} +impl UpdateStmt { + #[inline] + pub fn update_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::UPDATE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct UsingClause { + pub(crate) syntax: SyntaxNode, +} +impl UsingClause { + #[inline] + pub fn using_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::USING_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct UsingIndex { + pub(crate) syntax: SyntaxNode, +} +impl UsingIndex { + #[inline] + pub fn name_ref(&self) -> Option { + 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 struct VacuumStmt { + pub(crate) syntax: SyntaxNode, +} +impl VacuumStmt { + #[inline] + pub fn vacuum_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VACUUM_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +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 struct Values { + pub(crate) syntax: SyntaxNode, +} +impl Values { + #[inline] + pub fn values_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::VALUES_KW) + } +} + +#[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 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 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 ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) + } + #[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 expr(&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 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 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 WithTable { + pub(crate) syntax: SyntaxNode, +} +impl WithTable { + #[inline] + pub fn with_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::WITH_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 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 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 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), + Inherit(Inherit), + NoForceRls(NoForceRls), + NoInherit(NoInherit), + NotOf(NotOf), + OfType(OfType), + OwnerTo(OwnerTo), + RenameColumn(RenameColumn), + RenameConstraint(RenameConstraint), + RenameTable(RenameTable), + ReplicaIdentity(ReplicaIdentity), + SetAccessMethod(SetAccessMethod), + SetLogged(SetLogged), + SetSchema(SetSchema), + SetStorageParams(SetStorageParams), + SetTablespace(SetTablespace), + SetUnlogged(SetUnlogged), + SetWithoutCluster(SetWithoutCluster), + SetWithoutOids(SetWithoutOids), + ValidateConstraint(ValidateConstraint), +} + +#[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 Expr { + ArrayExpr(ArrayExpr), + BinExpr(BinExpr), + CallExpr(CallExpr), + CaseExpr(CaseExpr), + CastExpr(CastExpr), + FieldExpr(FieldExpr), + Literal(Literal), + NameRef(NameRef), +} + +#[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 ParamMode { + ParamIn(ParamIn), + ParamInOut(ParamInOut), + ParamOut(ParamOut), + ParamVariadic(ParamVariadic), +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum Stmt { + AlterAggregate(AlterAggregate), + AlterDomain(AlterDomain), + AlterTable(AlterTable), + Begin(Begin), + Commit(Commit), + CreateAggregate(CreateAggregate), + CreateDomain(CreateDomain), + CreateFunc(CreateFunc), + CreateIndex(CreateIndex), + CreateMaterializedViewStmt(CreateMaterializedViewStmt), + CreateTable(CreateTable), + CreateTableAsStmt(CreateTableAsStmt), + DeclareStmt(DeclareStmt), + DeleteStmt(DeleteStmt), + DropAggregate(DropAggregate), + DropDatabase(DropDatabase), + DropIndex(DropIndex), + DropTable(DropTable), + DropType(DropType), + ExecuteStmt(ExecuteStmt), + InsertStmt(InsertStmt), + MergeStmt(MergeStmt), + NotifyStmt(NotifyStmt), + ReleaseSavepointStmt(ReleaseSavepointStmt), + RevokeStmt(RevokeStmt), + Rollback(Rollback), + RollbackStmt(RollbackStmt), + SavepointStmt(SavepointStmt), + Select(Select), + TableStmt(TableStmt), + TruncateStmt(TruncateStmt), + UpdateStmt(UpdateStmt), + 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 TransactionMode { + Deferrable(Deferrable), + NotDeferrable(NotDeferrable), + ReadOnly(ReadOnly), + ReadWrite(ReadWrite), + TransactionModeIsolationLevel(TransactionModeIsolationLevel), +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum Type { + ArrayType(ArrayType), + BitType(BitType), + CharType(CharType), + DoubleType(DoubleType), + IntervalType(IntervalType), + PathType(PathType), + PercentType(PercentType), + TimeType(TimeType), +} +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 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 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 AlterAggregateStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_AGGREGATE_STMT + } + #[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 AlterCollationStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_COLLATION_STMT + } + #[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 AlterConversionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_CONVERSION_STMT + } + #[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 AlterDatabaseStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_DATABASE_STMT + } + #[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 AlterDefaultPrivilegesStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_DEFAULT_PRIVILEGES_STMT + } + #[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 AlterDomainStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_DOMAIN_STMT + } + #[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 AlterEventTriggerStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_EVENT_TRIGGER_STMT + } + #[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 AlterExtensionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_EXTENSION_STMT + } + #[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 AlterForeignDataWrapperStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_FOREIGN_DATA_WRAPPER_STMT + } + #[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 AlterForeignTableStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_FOREIGN_TABLE_STMT + } + #[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 AlterFunctionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_FUNCTION_STMT + } + #[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 AlterGroupStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_GROUP_STMT + } + #[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 AlterIndexStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_INDEX_STMT + } + #[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 AlterLanguageStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_LANGUAGE_STMT + } + #[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 AlterLargeObjectStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_LARGE_OBJECT_STMT + } + #[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 AlterMaterializedViewStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_MATERIALIZED_VIEW_STMT + } + #[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 AlterOperatorClassStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_OPERATOR_CLASS_STMT + } + #[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 AlterOperatorFamilyStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_OPERATOR_FAMILY_STMT + } + #[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 AlterOperatorStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_OPERATOR_STMT + } + #[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 AlterPolicyStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_POLICY_STMT + } + #[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 AlterProcedureStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_PROCEDURE_STMT + } + #[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 AlterPublicationStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_PUBLICATION_STMT + } + #[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 AlterRoleStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_ROLE_STMT + } + #[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 AlterRoutineStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_ROUTINE_STMT + } + #[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 AlterRuleStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_RULE_STMT + } + #[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 AlterSchemaStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_SCHEMA_STMT + } + #[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 AlterSequenceStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_SEQUENCE_STMT + } + #[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 AlterServerStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_SERVER_STMT + } + #[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 AlterStatisticsStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_STATISTICS_STMT + } + #[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 AlterSubscriptionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_SUBSCRIPTION_STMT + } + #[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 AlterSystemStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_SYSTEM_STMT + } + #[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 AlterTable { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_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 AlterTablespaceStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_TABLESPACE_STMT + } + #[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 AlterTextSearchConfigurationStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_TEXT_SEARCH_CONFIGURATION_STMT + } + #[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 AlterTextSearchDictionaryStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_TEXT_SEARCH_DICTIONARY_STMT + } + #[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 AlterTextSearchParserStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_TEXT_SEARCH_PARSER_STMT + } + #[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 AlterTextSearchTemplateStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_TEXT_SEARCH_TEMPLATE_STMT + } + #[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 AlterTriggerStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_TRIGGER_STMT + } + #[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 AlterTypeStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_TYPE_STMT + } + #[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 AlterUserMappingStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_USER_MAPPING_STMT + } + #[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 AlterUserStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_USER_STMT + } + #[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 AlterViewStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALTER_VIEW_STMT + } + #[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 AnalyzeStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ANALYZE_STMT + } + #[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 Arg { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ARG + } + #[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 ArgList { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ARG_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 ArrayExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ARRAY_EXPR + } + #[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 ArrayType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ARRAY_TYPE + } + #[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 AsFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::AS_FUNC_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 AtTimeZone { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::AT_TIME_ZONE + } + #[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 AttachPartition { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ATTACH_PARTITION + } + #[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 Begin { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::BEGIN + } + #[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 BeginFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::BEGIN_FUNC_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 BetweenExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::BETWEEN_EXPR + } + #[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 BinExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::BIN_EXPR + } + #[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 BitType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::BIT_TYPE + } + #[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 CallExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CALL_EXPR + } + #[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 CallStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CALL_STMT + } + #[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 CaseExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CASE_EXPR + } + #[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 CastExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CAST_EXPR + } + #[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 CharType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CHAR_TYPE + } + #[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 CheckConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CHECK_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 CheckpointStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CHECKPOINT_STMT + } + #[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 CloseStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CLOSE_STMT + } + #[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 ClusterOn { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CLUSTER_ON + } + #[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 ClusterStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CLUSTER_STMT + } + #[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 Collate { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::COLLATE + } + #[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 ColonColon { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::COLON_COLON + } + #[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 ColonEq { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::COLON_EQ + } + #[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 Column { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::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 ColumnList { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::COLUMN_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 CommentStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::COMMENT_STMT + } + #[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 Commit { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::COMMIT + } + #[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 CompoundSelect { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::COMPOUND_SELECT + } + #[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 ConstraintExclusions { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CONSTRAINT_EXCLUSIONS + } + #[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 ConstraintIncludeClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CONSTRAINT_INCLUDE_CLAUSE + } + #[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 ConstraintIndexMethod { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CONSTRAINT_INDEX_METHOD + } + #[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 ConstraintIndexTablespace { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CONSTRAINT_INDEX_TABLESPACE + } + #[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 ConstraintOptionList { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CONSTRAINT_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 ConstraintStorageParams { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CONSTRAINT_STORAGE_PARAMS + } + #[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 ConstraintWhereClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CONSTRAINT_WHERE_CLAUSE + } + #[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 CopyStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::COPY_STMT + } + #[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 CostFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::COST_FUNC_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 CreateAccessMethodStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_ACCESS_METHOD_STMT + } + #[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 CreateAggregate { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_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 CreateAggregateStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_AGGREGATE_STMT + } + #[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 CreateCastStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_CAST_STMT + } + #[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 CreateCollationStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_COLLATION_STMT + } + #[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 CreateConversionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_CONVERSION_STMT + } + #[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 CreateDatabaseStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_DATABASE_STMT + } + #[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 CreateDomain { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_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 CreateDomainStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_DOMAIN_STMT + } + #[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 CreateEventTriggerStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_EVENT_TRIGGER_STMT + } + #[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 CreateExtensionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_EXTENSION_STMT + } + #[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 CreateForeignDataWrapperStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_FOREIGN_DATA_WRAPPER_STMT + } + #[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 CreateForeignTableStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_FOREIGN_TABLE_STMT + } + #[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 CreateFunc { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_FUNC + } + #[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 CreateFunctionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_FUNCTION_STMT + } + #[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 CreateGroupStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_GROUP_STMT + } + #[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 CreateIndex { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_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 CreateLanguageStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_LANGUAGE_STMT + } + #[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 CreateMaterializedViewStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_MATERIALIZED_VIEW_STMT + } + #[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 CreateOperatorClassStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_OPERATOR_CLASS_STMT + } + #[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 CreateOperatorFamilyStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_OPERATOR_FAMILY_STMT + } + #[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 CreateOperatorStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_OPERATOR_STMT + } + #[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 CreatePolicyStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_POLICY_STMT + } + #[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 CreateProcedureStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_PROCEDURE_STMT + } + #[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 CreatePublicationStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_PUBLICATION_STMT + } + #[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 CreateRoleStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_ROLE_STMT + } + #[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 CreateRuleStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_RULE_STMT + } + #[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 CreateSchemaStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_SCHEMA_STMT + } + #[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 CreateSequenceStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_SEQUENCE_STMT + } + #[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 CreateServerStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_SERVER_STMT + } + #[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 CreateStatisticsStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_STATISTICS_STMT + } + #[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 CreateSubscriptionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_SUBSCRIPTION_STMT + } + #[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 CreateTable { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_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 CreateTableAsStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_TABLE_AS_STMT + } + #[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 CreateTablespaceStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_TABLESPACE_STMT + } + #[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 CreateTextSearchConfigurationStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_TEXT_SEARCH_CONFIGURATION_STMT + } + #[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 CreateTextSearchDictionaryStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_TEXT_SEARCH_DICTIONARY_STMT + } + #[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 CreateTextSearchParserStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_TEXT_SEARCH_PARSER_STMT + } + #[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 CreateTextSearchTemplateStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_TEXT_SEARCH_TEMPLATE_STMT + } + #[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 CreateTransformStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_TRANSFORM_STMT + } + #[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 CreateTriggerStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_TRIGGER_STMT + } + #[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 CreateTypeStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_TYPE_STMT + } + #[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 CreateUserMappingStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_USER_MAPPING_STMT + } + #[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 CreateUserStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_USER_STMT + } + #[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 CreateViewStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_VIEW_STMT + } + #[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 CustomOp { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CUSTOM_OP + } + #[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 DeallocateStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DEALLOCATE_STMT + } + #[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 DeclareStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DECLARE_STMT + } + #[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 DefaultConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DEFAULT_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 Deferrable { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DEFERRABLE + } + #[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 DeferrableConstraintOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DEFERRABLE_CONSTRAINT_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 DeleteStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DELETE_STMT + } + #[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 DetachPartition { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DETACH_PARTITION + } + #[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 DisableRls { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DISABLE_RLS + } + #[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 DisableRule { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DISABLE_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 DisableTrigger { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DISABLE_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 DiscardStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DISCARD_STMT + } + #[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 DistinctClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DISTINCT_CLAUSE + } + #[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 DoStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DO_STMT + } + #[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 DoubleType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DOUBLE_TYPE + } + #[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 DropAccessMethodStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_ACCESS_METHOD_STMT + } + #[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 DropAggregate { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_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 DropCastStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_CAST_STMT + } + #[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 DropCollationStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_COLLATION_STMT + } + #[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 DropColumn { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_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 DropConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_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 DropConversionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_CONVERSION_STMT + } + #[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 DropDatabase { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_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 DropDatabaseStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_DATABASE_STMT + } + #[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 DropDefault { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_DEFAULT + } + #[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 DropDomainStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_DOMAIN_STMT + } + #[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 DropEventTriggerStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_EVENT_TRIGGER_STMT + } + #[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 DropExpression { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_EXPRESSION + } + #[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 DropExtensionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_EXTENSION_STMT + } + #[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 DropForeignDataWrapperStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_FOREIGN_DATA_WRAPPER_STMT + } + #[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 DropForeignTableStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_FOREIGN_TABLE_STMT + } + #[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 DropFunctionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_FUNCTION_STMT + } + #[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 DropGroupStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_GROUP_STMT + } + #[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 DropIdentity { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_IDENTITY + } + #[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 DropIndex { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_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 DropIndexStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_INDEX_STMT + } + #[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 DropLanguageStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_LANGUAGE_STMT + } + #[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 DropMaterializedViewStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_MATERIALIZED_VIEW_STMT + } + #[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 DropNotNull { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_NOT_NULL + } + #[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 DropOperatorClassStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_OPERATOR_CLASS_STMT + } + #[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 DropOperatorFamilyStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_OPERATOR_FAMILY_STMT + } + #[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 DropOperatorStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_OPERATOR_STMT + } + #[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 DropOwnedStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_OWNED_STMT + } + #[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 DropPolicyStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_POLICY_STMT + } + #[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 DropProcedureStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_PROCEDURE_STMT + } + #[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 DropPublicationStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_PUBLICATION_STMT + } + #[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 DropRoleStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_ROLE_STMT + } + #[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 DropRoutineStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_ROUTINE_STMT + } + #[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 DropRuleStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_RULE_STMT + } + #[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 DropSchemaStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_SCHEMA_STMT + } + #[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 DropSequenceStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_SEQUENCE_STMT + } + #[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 DropServerStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_SERVER_STMT + } + #[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 DropStatisticsStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_STATISTICS_STMT + } + #[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 DropSubscriptionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_SUBSCRIPTION_STMT + } + #[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 DropTable { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_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 DropTablespaceStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_TABLESPACE_STMT + } + #[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 DropTextSearchConfigStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_TEXT_SEARCH_CONFIG_STMT + } + #[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 DropTextSearchDictStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_TEXT_SEARCH_DICT_STMT + } + #[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 DropTextSearchParserStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_TEXT_SEARCH_PARSER_STMT + } + #[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 DropTextSearchTemplateStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_TEXT_SEARCH_TEMPLATE_STMT + } + #[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 DropTransformStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_TRANSFORM_STMT + } + #[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 DropTriggerStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_TRIGGER_STMT + } + #[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 DropType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_TYPE + } + #[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 DropTypeStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_TYPE_STMT + } + #[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 DropUserMappingStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_USER_MAPPING_STMT + } + #[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 DropUserStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_USER_STMT + } + #[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 DropViewStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::DROP_VIEW_STMT + } + #[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 EnableAlwaysRule { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ENABLE_ALWAYS_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 EnableAlwaysTrigger { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ENABLE_ALWAYS_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 EnableReplicaRule { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ENABLE_REPLICA_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 EnableReplicaTrigger { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ENABLE_REPLICA_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 EnableRls { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ENABLE_RLS + } + #[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 EnableRule { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ENABLE_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 EnableTrigger { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ENABLE_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 ExcludeConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::EXCLUDE_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 ExecuteStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::EXECUTE_STMT + } + #[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 ExplainStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::EXPLAIN_STMT + } + #[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 FatArrow { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::FAT_ARROW + } + #[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 FetchStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::FETCH_STMT + } + #[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 FieldExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::FIELD_EXPR + } + #[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 FilterClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::FILTER_CLAUSE + } + #[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 ForceRls { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::FORCE_RLS + } + #[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 ForeignKeyConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::FOREIGN_KEY_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 FromClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::FROM_CLAUSE + } + #[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 FuncOptionList { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::FUNC_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 GeneratedConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::GENERATED_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 GrantStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::GRANT_STMT + } + #[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 GroupByClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::GROUP_BY_CLAUSE + } + #[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 Gteq { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::GTEQ + } + #[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 HavingClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::HAVING_CLAUSE + } + #[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 IfExists { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::IF_EXISTS + } + #[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 IfNotExists { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::IF_NOT_EXISTS + } + #[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 ImportForeignSchema { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::IMPORT_FOREIGN_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 IndexExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::INDEX_EXPR + } + #[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 IndexParams { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::INDEX_PARAMS + } + #[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 Inherit { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::INHERIT + } + #[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 InitiallyDeferredConstraintOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::INITIALLY_DEFERRED_CONSTRAINT_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 InitiallyImmediateConstraintOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::INITIALLY_IMMEDIATE_CONSTRAINT_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 InsertStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::INSERT_STMT + } + #[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 IntervalType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::INTERVAL_TYPE + } + #[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 IntoClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::INTO_CLAUSE + } + #[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 IsDistinctFrom { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::IS_DISTINCT_FROM + } + #[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 IsNot { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::IS_NOT + } + #[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 IsNotDistinctFrom { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::IS_NOT_DISTINCT_FROM + } + #[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 IsNull { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::IS_NULL + } + #[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 Join { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JOIN + } + #[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 JsonBehaviorClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_BEHAVIOR_CLAUSE + } + #[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 JsonFormatClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_FORMAT_CLAUSE + } + #[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 JsonKeyValue { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_KEY_VALUE + } + #[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 JsonKeysUniqueClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_KEYS_UNIQUE_CLAUSE + } + #[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 JsonNullClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_NULL_CLAUSE + } + #[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 JsonOnErrorClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_ON_ERROR_CLAUSE + } + #[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 JsonPassingClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_PASSING_CLAUSE + } + #[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 JsonQuotesClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_QUOTES_CLAUSE + } + #[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 JsonReturningClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_RETURNING_CLAUSE + } + #[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 JsonValueExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_VALUE_EXPR + } + #[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 JsonWrapperBehaviorClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::JSON_WRAPPER_BEHAVIOR_CLAUSE + } + #[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 LanguageFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::LANGUAGE_FUNC_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 LeakproofFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::LEAKPROOF_FUNC_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 LikeClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::LIKE_CLAUSE + } + #[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 LimitClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::LIMIT_CLAUSE + } + #[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 ListenStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::LISTEN_STMT + } + #[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 Literal { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::LITERAL + } + #[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 LoadStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::LOAD_STMT + } + #[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 LockStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::LOCK_STMT + } + #[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 LockingClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::LOCKING_CLAUSE + } + #[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 Lteq { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::LTEQ + } + #[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 MergeStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::MERGE_STMT + } + #[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 MoveStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::MOVE_STMT + } + #[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 Name { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NAME + } + #[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 NameRef { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NAME_REF + } + #[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 NamedArg { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NAMED_ARG + } + #[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 Neq { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NEQ + } + #[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 Neqb { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NEQB + } + #[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 NoForceRls { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NO_FORCE_RLS + } + #[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 NoInherit { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NO_INHERIT + } + #[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 NotDeferrable { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NOT_DEFERRABLE + } + #[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 NotDeferrableConstraintOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NOT_DEFERRABLE_CONSTRAINT_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 NotIn { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NOT_IN + } + #[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 NotLike { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NOT_LIKE + } + #[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 NotNullConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NOT_NULL_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 NotOf { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NOT_OF + } + #[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 NotValid { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NOT_VALID + } + #[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 NotifyStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NOTIFY_STMT + } + #[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 NullConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::NULL_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 OfType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::OF_TYPE + } + #[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 OffsetClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::OFFSET_CLAUSE + } + #[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 Op { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::OP + } + #[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 OperatorCall { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::OPERATOR_CALL + } + #[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 OrReplace { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::OR_REPLACE + } + #[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 OrderByClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ORDER_BY_CLAUSE + } + #[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 OverClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::OVER_CLAUSE + } + #[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 OwnerTo { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::OWNER_TO + } + #[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 ParallelFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PARALLEL_FUNC_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 Param { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PARAM + } + #[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 ParamDefault { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PARAM_DEFAULT + } + #[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 ParamIn { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PARAM_IN + } + #[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 ParamInOut { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PARAM_IN_OUT + } + #[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 ParamList { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PARAM_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 ParamOut { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PARAM_OUT + } + #[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 ParamVariadic { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PARAM_VARIADIC + } + #[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 ParenExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PAREN_EXPR + } + #[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 Path { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PATH + } + #[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 PathSegment { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PATH_SEGMENT + } + #[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 PathType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PATH_TYPE + } + #[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 PercentType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PERCENT_TYPE + } + #[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 PercentTypeClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PERCENT_TYPE_CLAUSE + } + #[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 PostfixExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::POSTFIX_EXPR + } + #[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 PrefixExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PREFIX_EXPR + } + #[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 PrepareStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PREPARE_STMT + } + #[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 PrepareTransactionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PREPARE_TRANSACTION_STMT + } + #[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 PrimaryKeyConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::PRIMARY_KEY_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 ReadCommitted { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::READ_COMMITTED + } + #[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 ReadOnly { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::READ_ONLY + } + #[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 ReadUncommitted { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::READ_UNCOMMITTED + } + #[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 ReadWrite { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::READ_WRITE + } + #[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 ReassignStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::REASSIGN_STMT + } + #[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 ReferencesConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::REFERENCES_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 RefreshStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::REFRESH_STMT + } + #[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 ReindexStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::REINDEX_STMT + } + #[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 RelationName { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RELATION_NAME + } + #[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 ReleaseSavepointStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RELEASE_SAVEPOINT_STMT + } + #[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 RenameColumn { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RENAME_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 RenameConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RENAME_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 RenameTable { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RENAME_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 RenameTo { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RENAME_TO + } + #[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 RepeatableRead { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::REPEATABLE_READ + } + #[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 ReplicaIdentity { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::REPLICA_IDENTITY + } + #[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 ResetFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RESET_FUNC_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 ResetOptions { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RESET_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 ResetStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RESET_STMT + } + #[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 ResetStorageParams { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RESET_STORAGE_PARAMS + } + #[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 Restart { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RESTART + } + #[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 RetType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RET_TYPE + } + #[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 ReturnFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::RETURN_FUNC_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 RevokeStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::REVOKE_STMT + } + #[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 Role { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::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 Rollback { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ROLLBACK + } + #[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 RollbackStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ROLLBACK_STMT + } + #[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 RowsFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ROWS_FUNC_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 SavepointStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SAVEPOINT_STMT + } + #[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 SecurityFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SECURITY_FUNC_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 SecurityLabelStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SECURITY_LABEL_STMT + } + #[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 Select { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SELECT + } + #[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 SelectClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SELECT_CLAUSE + } + #[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 SelectIntoStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SELECT_INTO_STMT + } + #[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 SequenceOptionList { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SEQUENCE_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 Serializable { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SERIALIZABLE + } + #[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 SetAccessMethod { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_ACCESS_METHOD + } + #[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 SetCompression { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_COMPRESSION + } + #[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 SetConstraintsStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_CONSTRAINTS_STMT + } + #[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 SetDefault { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_DEFAULT + } + #[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 SetExpression { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_EXPRESSION + } + #[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 SetFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_FUNC_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 SetGenerated { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_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 SetGeneratedOptions { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_GENERATED_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 SetLogged { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_LOGGED + } + #[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 SetNotNull { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_NOT_NULL + } + #[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 SetOptions { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_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 SetOptionsList { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_OPTIONS_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 SetRoleStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_ROLE_STMT + } + #[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 SetSchema { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_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 SetSequenceOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_SEQUENCE_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 SetSessionAuthStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_SESSION_AUTH_STMT + } + #[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 SetStatistics { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::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 + } +} +impl AstNode for SetStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_STMT + } + #[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 SetStorage { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_STORAGE + } + #[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 SetStorageParams { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_STORAGE_PARAMS + } + #[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 SetTablespace { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_TABLESPACE + } + #[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 SetTransactionStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_TRANSACTION_STMT + } + #[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 SetType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_TYPE + } + #[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 SetUnlogged { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_UNLOGGED + } + #[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 SetWithoutCluster { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_WITHOUT_CLUSTER + } + #[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 SetWithoutOids { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SET_WITHOUT_OIDS + } + #[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 ShowStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SHOW_STMT + } + #[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 SimilarTo { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SIMILAR_TO + } + #[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 SourceFile { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SOURCE_FILE + } + #[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 StrictFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::STRICT_FUNC_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 SupportFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::SUPPORT_FUNC_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 TableArgs { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TABLE_ARGS + } + #[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 TableList { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TABLE_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 TableStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TABLE_STMT + } + #[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 Target { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TARGET + } + #[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 TargetList { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TARGET_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 TimeType { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TIME_TYPE + } + #[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 TransactionModeIsolationLevel { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TRANSACTION_MODE_ISOLATION_LEVEL + } + #[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 TransactionModeList { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TRANSACTION_MODE_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 TransformFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TRANSFORM_FUNC_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 TruncateStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TRUNCATE_STMT + } + #[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 TupleExpr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TUPLE_EXPR + } + #[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 UniqueConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::UNIQUE_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 UnlistenStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::UNLISTEN_STMT + } + #[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 UpdateStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::UPDATE_STMT + } + #[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 UsingClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::USING_CLAUSE + } + #[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 UsingIndex { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::USING_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 VacuumStmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::VACUUM_STMT + } + #[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 ValidateConstraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::VALIDATE_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 Values { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::VALUES + } + #[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 VolatilityFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::VOLATILITY_FUNC_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 WhenClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::WHEN_CLAUSE + } + #[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 WhereClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::WHERE_CLAUSE + } + #[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 WindowClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::WINDOW_CLAUSE + } + #[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 WindowDef { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::WINDOW_DEF + } + #[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 WindowFuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::WINDOW_FUNC_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 WithClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::WITH_CLAUSE + } + #[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 WithTable { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::WITH_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 WithTimezone { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::WITH_TIMEZONE + } + #[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 WithinClause { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::WITHIN_CLAUSE + } + #[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 WithoutTimezone { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::WITHOUT_TIMEZONE + } + #[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 AlterDomainAction { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + matches!( + kind, + SyntaxKind::ADD_CONSTRAINT + | SyntaxKind::DROP_CONSTRAINT + | SyntaxKind::DROP_DEFAULT + | SyntaxKind::DROP_NOT_NULL + | SyntaxKind::OWNER_TO + | SyntaxKind::RENAME_CONSTRAINT + | SyntaxKind::RENAME_TO + | SyntaxKind::SET_DEFAULT + | SyntaxKind::SET_NOT_NULL + | SyntaxKind::SET_SCHEMA + | SyntaxKind::VALIDATE_CONSTRAINT + ) + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + let res = match syntax.kind() { + SyntaxKind::ADD_CONSTRAINT => { + AlterDomainAction::AddConstraint(AddConstraint { syntax }) + } + SyntaxKind::DROP_CONSTRAINT => { + AlterDomainAction::DropConstraint(DropConstraint { syntax }) + } + SyntaxKind::DROP_DEFAULT => AlterDomainAction::DropDefault(DropDefault { syntax }), + SyntaxKind::DROP_NOT_NULL => AlterDomainAction::DropNotNull(DropNotNull { syntax }), + SyntaxKind::OWNER_TO => AlterDomainAction::OwnerTo(OwnerTo { syntax }), + SyntaxKind::RENAME_CONSTRAINT => { + AlterDomainAction::RenameConstraint(RenameConstraint { syntax }) + } + SyntaxKind::RENAME_TO => AlterDomainAction::RenameTo(RenameTo { syntax }), + SyntaxKind::SET_DEFAULT => AlterDomainAction::SetDefault(SetDefault { syntax }), + SyntaxKind::SET_NOT_NULL => AlterDomainAction::SetNotNull(SetNotNull { syntax }), + SyntaxKind::SET_SCHEMA => AlterDomainAction::SetSchema(SetSchema { syntax }), + SyntaxKind::VALIDATE_CONSTRAINT => { + AlterDomainAction::ValidateConstraint(ValidateConstraint { syntax }) + } + _ => return None, + }; + Some(res) + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + match self { + AlterDomainAction::AddConstraint(it) => &it.syntax, + AlterDomainAction::DropConstraint(it) => &it.syntax, + AlterDomainAction::DropDefault(it) => &it.syntax, + AlterDomainAction::DropNotNull(it) => &it.syntax, + AlterDomainAction::OwnerTo(it) => &it.syntax, + AlterDomainAction::RenameConstraint(it) => &it.syntax, + AlterDomainAction::RenameTo(it) => &it.syntax, + AlterDomainAction::SetDefault(it) => &it.syntax, + AlterDomainAction::SetNotNull(it) => &it.syntax, + AlterDomainAction::SetSchema(it) => &it.syntax, + AlterDomainAction::ValidateConstraint(it) => &it.syntax, + } + } +} +impl From for AlterDomainAction { + #[inline] + fn from(node: AddConstraint) -> AlterDomainAction { + AlterDomainAction::AddConstraint(node) + } +} +impl From for AlterDomainAction { + #[inline] + fn from(node: DropConstraint) -> AlterDomainAction { + AlterDomainAction::DropConstraint(node) + } +} +impl From for AlterDomainAction { + #[inline] + fn from(node: DropDefault) -> AlterDomainAction { + AlterDomainAction::DropDefault(node) + } +} +impl From for AlterDomainAction { + #[inline] + fn from(node: DropNotNull) -> AlterDomainAction { + AlterDomainAction::DropNotNull(node) + } +} +impl From for AlterDomainAction { + #[inline] + fn from(node: OwnerTo) -> AlterDomainAction { + AlterDomainAction::OwnerTo(node) + } +} +impl From for AlterDomainAction { + #[inline] + fn from(node: RenameConstraint) -> AlterDomainAction { + AlterDomainAction::RenameConstraint(node) + } +} +impl From for AlterDomainAction { + #[inline] + fn from(node: RenameTo) -> AlterDomainAction { + AlterDomainAction::RenameTo(node) + } +} +impl From for AlterDomainAction { + #[inline] + fn from(node: SetDefault) -> AlterDomainAction { + AlterDomainAction::SetDefault(node) + } +} +impl From for AlterDomainAction { + #[inline] + fn from(node: SetNotNull) -> AlterDomainAction { + AlterDomainAction::SetNotNull(node) + } +} +impl From for AlterDomainAction { + #[inline] + fn from(node: SetSchema) -> AlterDomainAction { + AlterDomainAction::SetSchema(node) + } +} +impl From for AlterDomainAction { + #[inline] + fn from(node: ValidateConstraint) -> AlterDomainAction { + AlterDomainAction::ValidateConstraint(node) + } +} +impl AstNode for AlterTableAction { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + matches!( + kind, + SyntaxKind::ADD_COLUMN + | SyntaxKind::ADD_CONSTRAINT + | SyntaxKind::ALTER_COLUMN + | SyntaxKind::ALTER_CONSTRAINT + | SyntaxKind::ATTACH_PARTITION + | SyntaxKind::CLUSTER_ON + | SyntaxKind::DETACH_PARTITION + | SyntaxKind::DISABLE_RLS + | SyntaxKind::DISABLE_RULE + | SyntaxKind::DISABLE_TRIGGER + | SyntaxKind::DROP_COLUMN + | SyntaxKind::DROP_CONSTRAINT + | SyntaxKind::ENABLE_ALWAYS_RULE + | SyntaxKind::ENABLE_ALWAYS_TRIGGER + | SyntaxKind::ENABLE_REPLICA_RULE + | SyntaxKind::ENABLE_REPLICA_TRIGGER + | SyntaxKind::ENABLE_RLS + | SyntaxKind::ENABLE_RULE + | SyntaxKind::ENABLE_TRIGGER + | SyntaxKind::FORCE_RLS + | SyntaxKind::INHERIT + | SyntaxKind::NO_FORCE_RLS + | SyntaxKind::NO_INHERIT + | SyntaxKind::NOT_OF + | SyntaxKind::OF_TYPE + | SyntaxKind::OWNER_TO + | SyntaxKind::RENAME_COLUMN + | SyntaxKind::RENAME_CONSTRAINT + | SyntaxKind::RENAME_TABLE + | SyntaxKind::REPLICA_IDENTITY + | SyntaxKind::SET_ACCESS_METHOD + | SyntaxKind::SET_LOGGED + | SyntaxKind::SET_SCHEMA + | SyntaxKind::SET_STORAGE_PARAMS + | SyntaxKind::SET_TABLESPACE + | SyntaxKind::SET_UNLOGGED + | SyntaxKind::SET_WITHOUT_CLUSTER + | SyntaxKind::SET_WITHOUT_OIDS + | SyntaxKind::VALIDATE_CONSTRAINT + ) + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + let res = match syntax.kind() { + SyntaxKind::ADD_COLUMN => AlterTableAction::AddColumn(AddColumn { syntax }), + SyntaxKind::ADD_CONSTRAINT => AlterTableAction::AddConstraint(AddConstraint { syntax }), + SyntaxKind::ALTER_COLUMN => AlterTableAction::AlterColumn(AlterColumn { syntax }), + SyntaxKind::ALTER_CONSTRAINT => { + AlterTableAction::AlterConstraint(AlterConstraint { syntax }) + } + SyntaxKind::ATTACH_PARTITION => { + AlterTableAction::AttachPartition(AttachPartition { syntax }) + } + SyntaxKind::CLUSTER_ON => AlterTableAction::ClusterOn(ClusterOn { syntax }), + SyntaxKind::DETACH_PARTITION => { + AlterTableAction::DetachPartition(DetachPartition { syntax }) + } + SyntaxKind::DISABLE_RLS => AlterTableAction::DisableRls(DisableRls { syntax }), + SyntaxKind::DISABLE_RULE => AlterTableAction::DisableRule(DisableRule { syntax }), + SyntaxKind::DISABLE_TRIGGER => { + AlterTableAction::DisableTrigger(DisableTrigger { syntax }) + } + SyntaxKind::DROP_COLUMN => AlterTableAction::DropColumn(DropColumn { syntax }), + SyntaxKind::DROP_CONSTRAINT => { + AlterTableAction::DropConstraint(DropConstraint { syntax }) + } + SyntaxKind::ENABLE_ALWAYS_RULE => { + AlterTableAction::EnableAlwaysRule(EnableAlwaysRule { syntax }) + } + SyntaxKind::ENABLE_ALWAYS_TRIGGER => { + AlterTableAction::EnableAlwaysTrigger(EnableAlwaysTrigger { syntax }) + } + SyntaxKind::ENABLE_REPLICA_RULE => { + AlterTableAction::EnableReplicaRule(EnableReplicaRule { syntax }) + } + SyntaxKind::ENABLE_REPLICA_TRIGGER => { + AlterTableAction::EnableReplicaTrigger(EnableReplicaTrigger { syntax }) + } + SyntaxKind::ENABLE_RLS => AlterTableAction::EnableRls(EnableRls { syntax }), + SyntaxKind::ENABLE_RULE => AlterTableAction::EnableRule(EnableRule { syntax }), + SyntaxKind::ENABLE_TRIGGER => AlterTableAction::EnableTrigger(EnableTrigger { syntax }), + SyntaxKind::FORCE_RLS => AlterTableAction::ForceRls(ForceRls { syntax }), + SyntaxKind::INHERIT => AlterTableAction::Inherit(Inherit { syntax }), + SyntaxKind::NO_FORCE_RLS => AlterTableAction::NoForceRls(NoForceRls { syntax }), + SyntaxKind::NO_INHERIT => AlterTableAction::NoInherit(NoInherit { syntax }), + SyntaxKind::NOT_OF => AlterTableAction::NotOf(NotOf { syntax }), + SyntaxKind::OF_TYPE => AlterTableAction::OfType(OfType { syntax }), + SyntaxKind::OWNER_TO => AlterTableAction::OwnerTo(OwnerTo { syntax }), + SyntaxKind::RENAME_COLUMN => AlterTableAction::RenameColumn(RenameColumn { syntax }), + SyntaxKind::RENAME_CONSTRAINT => { + AlterTableAction::RenameConstraint(RenameConstraint { syntax }) + } + SyntaxKind::RENAME_TABLE => AlterTableAction::RenameTable(RenameTable { syntax }), + SyntaxKind::REPLICA_IDENTITY => { + AlterTableAction::ReplicaIdentity(ReplicaIdentity { syntax }) + } + SyntaxKind::SET_ACCESS_METHOD => { + AlterTableAction::SetAccessMethod(SetAccessMethod { syntax }) + } + SyntaxKind::SET_LOGGED => AlterTableAction::SetLogged(SetLogged { syntax }), + SyntaxKind::SET_SCHEMA => AlterTableAction::SetSchema(SetSchema { syntax }), + SyntaxKind::SET_STORAGE_PARAMS => { + AlterTableAction::SetStorageParams(SetStorageParams { syntax }) + } + SyntaxKind::SET_TABLESPACE => AlterTableAction::SetTablespace(SetTablespace { syntax }), + SyntaxKind::SET_UNLOGGED => AlterTableAction::SetUnlogged(SetUnlogged { syntax }), + SyntaxKind::SET_WITHOUT_CLUSTER => { + AlterTableAction::SetWithoutCluster(SetWithoutCluster { syntax }) + } + SyntaxKind::SET_WITHOUT_OIDS => { + AlterTableAction::SetWithoutOids(SetWithoutOids { syntax }) + } + SyntaxKind::VALIDATE_CONSTRAINT => { + AlterTableAction::ValidateConstraint(ValidateConstraint { syntax }) + } + _ => return None, + }; + Some(res) + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + match self { + AlterTableAction::AddColumn(it) => &it.syntax, + AlterTableAction::AddConstraint(it) => &it.syntax, + AlterTableAction::AlterColumn(it) => &it.syntax, + AlterTableAction::AlterConstraint(it) => &it.syntax, + AlterTableAction::AttachPartition(it) => &it.syntax, + AlterTableAction::ClusterOn(it) => &it.syntax, + AlterTableAction::DetachPartition(it) => &it.syntax, + AlterTableAction::DisableRls(it) => &it.syntax, + AlterTableAction::DisableRule(it) => &it.syntax, + AlterTableAction::DisableTrigger(it) => &it.syntax, + AlterTableAction::DropColumn(it) => &it.syntax, + AlterTableAction::DropConstraint(it) => &it.syntax, + AlterTableAction::EnableAlwaysRule(it) => &it.syntax, + AlterTableAction::EnableAlwaysTrigger(it) => &it.syntax, + AlterTableAction::EnableReplicaRule(it) => &it.syntax, + AlterTableAction::EnableReplicaTrigger(it) => &it.syntax, + AlterTableAction::EnableRls(it) => &it.syntax, + AlterTableAction::EnableRule(it) => &it.syntax, + AlterTableAction::EnableTrigger(it) => &it.syntax, + AlterTableAction::ForceRls(it) => &it.syntax, + AlterTableAction::Inherit(it) => &it.syntax, + AlterTableAction::NoForceRls(it) => &it.syntax, + AlterTableAction::NoInherit(it) => &it.syntax, + AlterTableAction::NotOf(it) => &it.syntax, + AlterTableAction::OfType(it) => &it.syntax, + AlterTableAction::OwnerTo(it) => &it.syntax, + AlterTableAction::RenameColumn(it) => &it.syntax, + AlterTableAction::RenameConstraint(it) => &it.syntax, + AlterTableAction::RenameTable(it) => &it.syntax, + AlterTableAction::ReplicaIdentity(it) => &it.syntax, + AlterTableAction::SetAccessMethod(it) => &it.syntax, + AlterTableAction::SetLogged(it) => &it.syntax, + AlterTableAction::SetSchema(it) => &it.syntax, + AlterTableAction::SetStorageParams(it) => &it.syntax, + AlterTableAction::SetTablespace(it) => &it.syntax, + AlterTableAction::SetUnlogged(it) => &it.syntax, + AlterTableAction::SetWithoutCluster(it) => &it.syntax, + AlterTableAction::SetWithoutOids(it) => &it.syntax, + AlterTableAction::ValidateConstraint(it) => &it.syntax, + } + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: AddColumn) -> AlterTableAction { + AlterTableAction::AddColumn(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: AddConstraint) -> AlterTableAction { + AlterTableAction::AddConstraint(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: AlterColumn) -> AlterTableAction { + AlterTableAction::AlterColumn(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: AlterConstraint) -> AlterTableAction { + AlterTableAction::AlterConstraint(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: AttachPartition) -> AlterTableAction { + AlterTableAction::AttachPartition(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: ClusterOn) -> AlterTableAction { + AlterTableAction::ClusterOn(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: DetachPartition) -> AlterTableAction { + AlterTableAction::DetachPartition(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: DisableRls) -> AlterTableAction { + AlterTableAction::DisableRls(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: DisableRule) -> AlterTableAction { + AlterTableAction::DisableRule(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: DisableTrigger) -> AlterTableAction { + AlterTableAction::DisableTrigger(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: DropColumn) -> AlterTableAction { + AlterTableAction::DropColumn(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: DropConstraint) -> AlterTableAction { + AlterTableAction::DropConstraint(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: EnableAlwaysRule) -> AlterTableAction { + AlterTableAction::EnableAlwaysRule(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: EnableAlwaysTrigger) -> AlterTableAction { + AlterTableAction::EnableAlwaysTrigger(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: EnableReplicaRule) -> AlterTableAction { + AlterTableAction::EnableReplicaRule(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: EnableReplicaTrigger) -> AlterTableAction { + AlterTableAction::EnableReplicaTrigger(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: EnableRls) -> AlterTableAction { + AlterTableAction::EnableRls(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: EnableRule) -> AlterTableAction { + AlterTableAction::EnableRule(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: EnableTrigger) -> AlterTableAction { + AlterTableAction::EnableTrigger(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: ForceRls) -> AlterTableAction { + AlterTableAction::ForceRls(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: Inherit) -> AlterTableAction { + AlterTableAction::Inherit(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: NoForceRls) -> AlterTableAction { + AlterTableAction::NoForceRls(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: NoInherit) -> AlterTableAction { + AlterTableAction::NoInherit(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: NotOf) -> AlterTableAction { + AlterTableAction::NotOf(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: OfType) -> AlterTableAction { + AlterTableAction::OfType(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: OwnerTo) -> AlterTableAction { + AlterTableAction::OwnerTo(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: RenameColumn) -> AlterTableAction { + AlterTableAction::RenameColumn(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: RenameConstraint) -> AlterTableAction { + AlterTableAction::RenameConstraint(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: RenameTable) -> AlterTableAction { + AlterTableAction::RenameTable(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: ReplicaIdentity) -> AlterTableAction { + AlterTableAction::ReplicaIdentity(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: SetAccessMethod) -> AlterTableAction { + AlterTableAction::SetAccessMethod(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: SetLogged) -> AlterTableAction { + AlterTableAction::SetLogged(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: SetSchema) -> AlterTableAction { + AlterTableAction::SetSchema(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: SetStorageParams) -> AlterTableAction { + AlterTableAction::SetStorageParams(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: SetTablespace) -> AlterTableAction { + AlterTableAction::SetTablespace(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: SetUnlogged) -> AlterTableAction { + AlterTableAction::SetUnlogged(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: SetWithoutCluster) -> AlterTableAction { + AlterTableAction::SetWithoutCluster(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: SetWithoutOids) -> AlterTableAction { + AlterTableAction::SetWithoutOids(node) + } +} +impl From for AlterTableAction { + #[inline] + fn from(node: ValidateConstraint) -> AlterTableAction { + AlterTableAction::ValidateConstraint(node) + } +} +impl AstNode for Constraint { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + matches!( + kind, + SyntaxKind::CHECK_CONSTRAINT + | SyntaxKind::DEFAULT_CONSTRAINT + | SyntaxKind::FOREIGN_KEY_CONSTRAINT + | SyntaxKind::GENERATED_CONSTRAINT + | SyntaxKind::NOT_NULL_CONSTRAINT + | SyntaxKind::NULL_CONSTRAINT + | SyntaxKind::PRIMARY_KEY_CONSTRAINT + | SyntaxKind::REFERENCES_CONSTRAINT + | SyntaxKind::UNIQUE_CONSTRAINT + ) + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + let res = match syntax.kind() { + SyntaxKind::CHECK_CONSTRAINT => Constraint::CheckConstraint(CheckConstraint { syntax }), + SyntaxKind::DEFAULT_CONSTRAINT => { + Constraint::DefaultConstraint(DefaultConstraint { syntax }) + } + SyntaxKind::FOREIGN_KEY_CONSTRAINT => { + Constraint::ForeignKeyConstraint(ForeignKeyConstraint { syntax }) + } + SyntaxKind::GENERATED_CONSTRAINT => { + Constraint::GeneratedConstraint(GeneratedConstraint { syntax }) + } + SyntaxKind::NOT_NULL_CONSTRAINT => { + Constraint::NotNullConstraint(NotNullConstraint { syntax }) + } + SyntaxKind::NULL_CONSTRAINT => Constraint::NullConstraint(NullConstraint { syntax }), + SyntaxKind::PRIMARY_KEY_CONSTRAINT => { + Constraint::PrimaryKeyConstraint(PrimaryKeyConstraint { syntax }) + } + SyntaxKind::REFERENCES_CONSTRAINT => { + Constraint::ReferencesConstraint(ReferencesConstraint { syntax }) + } + SyntaxKind::UNIQUE_CONSTRAINT => { + Constraint::UniqueConstraint(UniqueConstraint { syntax }) + } + _ => return None, + }; + Some(res) + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + match self { + Constraint::CheckConstraint(it) => &it.syntax, + Constraint::DefaultConstraint(it) => &it.syntax, + Constraint::ForeignKeyConstraint(it) => &it.syntax, + Constraint::GeneratedConstraint(it) => &it.syntax, + Constraint::NotNullConstraint(it) => &it.syntax, + Constraint::NullConstraint(it) => &it.syntax, + Constraint::PrimaryKeyConstraint(it) => &it.syntax, + Constraint::ReferencesConstraint(it) => &it.syntax, + Constraint::UniqueConstraint(it) => &it.syntax, + } + } +} +impl From for Constraint { + #[inline] + fn from(node: CheckConstraint) -> Constraint { + Constraint::CheckConstraint(node) + } +} +impl From for Constraint { + #[inline] + fn from(node: DefaultConstraint) -> Constraint { + Constraint::DefaultConstraint(node) + } +} +impl From for Constraint { + #[inline] + fn from(node: ForeignKeyConstraint) -> Constraint { + Constraint::ForeignKeyConstraint(node) + } +} +impl From for Constraint { + #[inline] + fn from(node: GeneratedConstraint) -> Constraint { + Constraint::GeneratedConstraint(node) + } +} +impl From for Constraint { + #[inline] + fn from(node: NotNullConstraint) -> Constraint { + Constraint::NotNullConstraint(node) + } +} +impl From for Constraint { + #[inline] + fn from(node: NullConstraint) -> Constraint { + Constraint::NullConstraint(node) + } +} +impl From for Constraint { + #[inline] + fn from(node: PrimaryKeyConstraint) -> Constraint { + Constraint::PrimaryKeyConstraint(node) + } +} +impl From for Constraint { + #[inline] + fn from(node: ReferencesConstraint) -> Constraint { + Constraint::ReferencesConstraint(node) + } +} +impl From for Constraint { + #[inline] + fn from(node: UniqueConstraint) -> Constraint { + Constraint::UniqueConstraint(node) + } +} +impl AstNode for Expr { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + matches!( + kind, + SyntaxKind::ARRAY_EXPR + | SyntaxKind::BIN_EXPR + | SyntaxKind::CALL_EXPR + | SyntaxKind::CASE_EXPR + | SyntaxKind::CAST_EXPR + | SyntaxKind::FIELD_EXPR + | SyntaxKind::LITERAL + | SyntaxKind::NAME_REF + ) + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + let res = match syntax.kind() { + SyntaxKind::ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }), + SyntaxKind::BIN_EXPR => Expr::BinExpr(BinExpr { syntax }), + SyntaxKind::CALL_EXPR => Expr::CallExpr(CallExpr { syntax }), + SyntaxKind::CASE_EXPR => Expr::CaseExpr(CaseExpr { syntax }), + SyntaxKind::CAST_EXPR => Expr::CastExpr(CastExpr { syntax }), + SyntaxKind::FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }), + SyntaxKind::LITERAL => Expr::Literal(Literal { syntax }), + SyntaxKind::NAME_REF => Expr::NameRef(NameRef { syntax }), + _ => return None, + }; + Some(res) + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + match self { + Expr::ArrayExpr(it) => &it.syntax, + Expr::BinExpr(it) => &it.syntax, + Expr::CallExpr(it) => &it.syntax, + Expr::CaseExpr(it) => &it.syntax, + Expr::CastExpr(it) => &it.syntax, + Expr::FieldExpr(it) => &it.syntax, + Expr::Literal(it) => &it.syntax, + Expr::NameRef(it) => &it.syntax, + } + } +} +impl From for Expr { + #[inline] + fn from(node: ArrayExpr) -> Expr { + Expr::ArrayExpr(node) + } +} +impl From for Expr { + #[inline] + fn from(node: BinExpr) -> Expr { + Expr::BinExpr(node) + } +} +impl From for Expr { + #[inline] + fn from(node: CallExpr) -> Expr { + Expr::CallExpr(node) + } +} +impl From for Expr { + #[inline] + fn from(node: CaseExpr) -> Expr { + Expr::CaseExpr(node) + } +} +impl From for Expr { + #[inline] + fn from(node: CastExpr) -> Expr { + Expr::CastExpr(node) + } +} +impl From for Expr { + #[inline] + fn from(node: FieldExpr) -> Expr { + Expr::FieldExpr(node) + } +} +impl From for Expr { + #[inline] + fn from(node: Literal) -> Expr { + Expr::Literal(node) + } +} +impl From for Expr { + #[inline] + fn from(node: NameRef) -> Expr { + Expr::NameRef(node) + } +} +impl AstNode for FuncOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + matches!( + kind, + SyntaxKind::AS_FUNC_OPTION + | SyntaxKind::BEGIN_FUNC_OPTION + | SyntaxKind::COST_FUNC_OPTION + | SyntaxKind::LANGUAGE_FUNC_OPTION + | SyntaxKind::LEAKPROOF_FUNC_OPTION + | SyntaxKind::PARALLEL_FUNC_OPTION + | SyntaxKind::RESET_FUNC_OPTION + | SyntaxKind::RETURN_FUNC_OPTION + | SyntaxKind::ROWS_FUNC_OPTION + | SyntaxKind::SECURITY_FUNC_OPTION + | SyntaxKind::SET_FUNC_OPTION + | SyntaxKind::STRICT_FUNC_OPTION + | SyntaxKind::SUPPORT_FUNC_OPTION + | SyntaxKind::TRANSFORM_FUNC_OPTION + | SyntaxKind::VOLATILITY_FUNC_OPTION + | SyntaxKind::WINDOW_FUNC_OPTION + ) + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + let res = match syntax.kind() { + SyntaxKind::AS_FUNC_OPTION => FuncOption::AsFuncOption(AsFuncOption { syntax }), + SyntaxKind::BEGIN_FUNC_OPTION => { + FuncOption::BeginFuncOption(BeginFuncOption { syntax }) + } + SyntaxKind::COST_FUNC_OPTION => FuncOption::CostFuncOption(CostFuncOption { syntax }), + SyntaxKind::LANGUAGE_FUNC_OPTION => { + FuncOption::LanguageFuncOption(LanguageFuncOption { syntax }) + } + SyntaxKind::LEAKPROOF_FUNC_OPTION => { + FuncOption::LeakproofFuncOption(LeakproofFuncOption { syntax }) + } + SyntaxKind::PARALLEL_FUNC_OPTION => { + FuncOption::ParallelFuncOption(ParallelFuncOption { syntax }) + } + SyntaxKind::RESET_FUNC_OPTION => { + FuncOption::ResetFuncOption(ResetFuncOption { syntax }) + } + SyntaxKind::RETURN_FUNC_OPTION => { + FuncOption::ReturnFuncOption(ReturnFuncOption { syntax }) + } + SyntaxKind::ROWS_FUNC_OPTION => FuncOption::RowsFuncOption(RowsFuncOption { syntax }), + SyntaxKind::SECURITY_FUNC_OPTION => { + FuncOption::SecurityFuncOption(SecurityFuncOption { syntax }) + } + SyntaxKind::SET_FUNC_OPTION => FuncOption::SetFuncOption(SetFuncOption { syntax }), + SyntaxKind::STRICT_FUNC_OPTION => { + FuncOption::StrictFuncOption(StrictFuncOption { syntax }) + } + SyntaxKind::SUPPORT_FUNC_OPTION => { + FuncOption::SupportFuncOption(SupportFuncOption { syntax }) + } + SyntaxKind::TRANSFORM_FUNC_OPTION => { + FuncOption::TransformFuncOption(TransformFuncOption { syntax }) + } + SyntaxKind::VOLATILITY_FUNC_OPTION => { + FuncOption::VolatilityFuncOption(VolatilityFuncOption { syntax }) + } + SyntaxKind::WINDOW_FUNC_OPTION => { + FuncOption::WindowFuncOption(WindowFuncOption { syntax }) + } + _ => return None, + }; + Some(res) + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + match self { + FuncOption::AsFuncOption(it) => &it.syntax, + FuncOption::BeginFuncOption(it) => &it.syntax, + FuncOption::CostFuncOption(it) => &it.syntax, + FuncOption::LanguageFuncOption(it) => &it.syntax, + FuncOption::LeakproofFuncOption(it) => &it.syntax, + FuncOption::ParallelFuncOption(it) => &it.syntax, + FuncOption::ResetFuncOption(it) => &it.syntax, + FuncOption::ReturnFuncOption(it) => &it.syntax, + FuncOption::RowsFuncOption(it) => &it.syntax, + FuncOption::SecurityFuncOption(it) => &it.syntax, + FuncOption::SetFuncOption(it) => &it.syntax, + FuncOption::StrictFuncOption(it) => &it.syntax, + FuncOption::SupportFuncOption(it) => &it.syntax, + FuncOption::TransformFuncOption(it) => &it.syntax, + FuncOption::VolatilityFuncOption(it) => &it.syntax, + FuncOption::WindowFuncOption(it) => &it.syntax, + } + } +} +impl From for FuncOption { + #[inline] + fn from(node: AsFuncOption) -> FuncOption { + FuncOption::AsFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: BeginFuncOption) -> FuncOption { + FuncOption::BeginFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: CostFuncOption) -> FuncOption { + FuncOption::CostFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: LanguageFuncOption) -> FuncOption { + FuncOption::LanguageFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: LeakproofFuncOption) -> FuncOption { + FuncOption::LeakproofFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: ParallelFuncOption) -> FuncOption { + FuncOption::ParallelFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: ResetFuncOption) -> FuncOption { + FuncOption::ResetFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: ReturnFuncOption) -> FuncOption { + FuncOption::ReturnFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: RowsFuncOption) -> FuncOption { + FuncOption::RowsFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: SecurityFuncOption) -> FuncOption { + FuncOption::SecurityFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: SetFuncOption) -> FuncOption { + FuncOption::SetFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: StrictFuncOption) -> FuncOption { + FuncOption::StrictFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: SupportFuncOption) -> FuncOption { + FuncOption::SupportFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: TransformFuncOption) -> FuncOption { + FuncOption::TransformFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: VolatilityFuncOption) -> FuncOption { + FuncOption::VolatilityFuncOption(node) + } +} +impl From for FuncOption { + #[inline] + fn from(node: WindowFuncOption) -> FuncOption { + FuncOption::WindowFuncOption(node) + } +} +impl AstNode for ParamMode { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + matches!( + kind, + SyntaxKind::PARAM_IN + | SyntaxKind::PARAM_IN_OUT + | SyntaxKind::PARAM_OUT + | SyntaxKind::PARAM_VARIADIC + ) + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + let res = match syntax.kind() { + SyntaxKind::PARAM_IN => ParamMode::ParamIn(ParamIn { syntax }), + SyntaxKind::PARAM_IN_OUT => ParamMode::ParamInOut(ParamInOut { syntax }), + SyntaxKind::PARAM_OUT => ParamMode::ParamOut(ParamOut { syntax }), + SyntaxKind::PARAM_VARIADIC => ParamMode::ParamVariadic(ParamVariadic { syntax }), + _ => return None, + }; + Some(res) + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + match self { + ParamMode::ParamIn(it) => &it.syntax, + ParamMode::ParamInOut(it) => &it.syntax, + ParamMode::ParamOut(it) => &it.syntax, + ParamMode::ParamVariadic(it) => &it.syntax, + } + } +} +impl From for ParamMode { + #[inline] + fn from(node: ParamIn) -> ParamMode { + ParamMode::ParamIn(node) + } +} +impl From for ParamMode { + #[inline] + fn from(node: ParamInOut) -> ParamMode { + ParamMode::ParamInOut(node) + } +} +impl From for ParamMode { + #[inline] + fn from(node: ParamOut) -> ParamMode { + ParamMode::ParamOut(node) + } +} +impl From for ParamMode { + #[inline] + fn from(node: ParamVariadic) -> ParamMode { + ParamMode::ParamVariadic(node) + } +} +impl AstNode for Stmt { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + matches!( + kind, + SyntaxKind::ALTER_AGGREGATE + | SyntaxKind::ALTER_DOMAIN + | SyntaxKind::ALTER_TABLE + | SyntaxKind::BEGIN + | SyntaxKind::COMMIT + | SyntaxKind::CREATE_AGGREGATE + | SyntaxKind::CREATE_DOMAIN + | SyntaxKind::CREATE_FUNC + | SyntaxKind::CREATE_INDEX + | SyntaxKind::CREATE_MATERIALIZED_VIEW_STMT + | SyntaxKind::CREATE_TABLE + | SyntaxKind::CREATE_TABLE_AS_STMT + | SyntaxKind::DECLARE_STMT + | SyntaxKind::DELETE_STMT + | SyntaxKind::DROP_AGGREGATE + | SyntaxKind::DROP_DATABASE + | SyntaxKind::DROP_INDEX + | SyntaxKind::DROP_TABLE + | SyntaxKind::DROP_TYPE + | SyntaxKind::EXECUTE_STMT + | SyntaxKind::INSERT_STMT + | SyntaxKind::MERGE_STMT + | SyntaxKind::NOTIFY_STMT + | SyntaxKind::RELEASE_SAVEPOINT_STMT + | SyntaxKind::REVOKE_STMT + | SyntaxKind::ROLLBACK + | SyntaxKind::ROLLBACK_STMT + | SyntaxKind::SAVEPOINT_STMT + | SyntaxKind::SELECT + | SyntaxKind::TABLE_STMT + | SyntaxKind::TRUNCATE_STMT + | SyntaxKind::UPDATE_STMT + | SyntaxKind::VALUES + ) + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + let res = match syntax.kind() { + SyntaxKind::ALTER_AGGREGATE => Stmt::AlterAggregate(AlterAggregate { syntax }), + SyntaxKind::ALTER_DOMAIN => Stmt::AlterDomain(AlterDomain { syntax }), + SyntaxKind::ALTER_TABLE => Stmt::AlterTable(AlterTable { syntax }), + SyntaxKind::BEGIN => Stmt::Begin(Begin { syntax }), + SyntaxKind::COMMIT => Stmt::Commit(Commit { syntax }), + SyntaxKind::CREATE_AGGREGATE => Stmt::CreateAggregate(CreateAggregate { syntax }), + SyntaxKind::CREATE_DOMAIN => Stmt::CreateDomain(CreateDomain { syntax }), + SyntaxKind::CREATE_FUNC => Stmt::CreateFunc(CreateFunc { syntax }), + SyntaxKind::CREATE_INDEX => Stmt::CreateIndex(CreateIndex { syntax }), + SyntaxKind::CREATE_MATERIALIZED_VIEW_STMT => { + Stmt::CreateMaterializedViewStmt(CreateMaterializedViewStmt { syntax }) + } + SyntaxKind::CREATE_TABLE => Stmt::CreateTable(CreateTable { syntax }), + SyntaxKind::CREATE_TABLE_AS_STMT => { + Stmt::CreateTableAsStmt(CreateTableAsStmt { syntax }) + } + SyntaxKind::DECLARE_STMT => Stmt::DeclareStmt(DeclareStmt { syntax }), + SyntaxKind::DELETE_STMT => Stmt::DeleteStmt(DeleteStmt { syntax }), + SyntaxKind::DROP_AGGREGATE => Stmt::DropAggregate(DropAggregate { syntax }), + SyntaxKind::DROP_DATABASE => Stmt::DropDatabase(DropDatabase { syntax }), + SyntaxKind::DROP_INDEX => Stmt::DropIndex(DropIndex { syntax }), + SyntaxKind::DROP_TABLE => Stmt::DropTable(DropTable { syntax }), + SyntaxKind::DROP_TYPE => Stmt::DropType(DropType { syntax }), + SyntaxKind::EXECUTE_STMT => Stmt::ExecuteStmt(ExecuteStmt { syntax }), + SyntaxKind::INSERT_STMT => Stmt::InsertStmt(InsertStmt { syntax }), + SyntaxKind::MERGE_STMT => Stmt::MergeStmt(MergeStmt { syntax }), + SyntaxKind::NOTIFY_STMT => Stmt::NotifyStmt(NotifyStmt { syntax }), + SyntaxKind::RELEASE_SAVEPOINT_STMT => { + Stmt::ReleaseSavepointStmt(ReleaseSavepointStmt { syntax }) + } + SyntaxKind::REVOKE_STMT => Stmt::RevokeStmt(RevokeStmt { syntax }), + SyntaxKind::ROLLBACK => Stmt::Rollback(Rollback { syntax }), + SyntaxKind::ROLLBACK_STMT => Stmt::RollbackStmt(RollbackStmt { syntax }), + SyntaxKind::SAVEPOINT_STMT => Stmt::SavepointStmt(SavepointStmt { syntax }), + SyntaxKind::SELECT => Stmt::Select(Select { syntax }), + SyntaxKind::TABLE_STMT => Stmt::TableStmt(TableStmt { syntax }), + SyntaxKind::TRUNCATE_STMT => Stmt::TruncateStmt(TruncateStmt { syntax }), + SyntaxKind::UPDATE_STMT => Stmt::UpdateStmt(UpdateStmt { syntax }), + SyntaxKind::VALUES => Stmt::Values(Values { syntax }), + _ => return None, + }; + Some(res) + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + match self { + Stmt::AlterAggregate(it) => &it.syntax, + Stmt::AlterDomain(it) => &it.syntax, + Stmt::AlterTable(it) => &it.syntax, + Stmt::Begin(it) => &it.syntax, + Stmt::Commit(it) => &it.syntax, + Stmt::CreateAggregate(it) => &it.syntax, + Stmt::CreateDomain(it) => &it.syntax, + Stmt::CreateFunc(it) => &it.syntax, + Stmt::CreateIndex(it) => &it.syntax, + Stmt::CreateMaterializedViewStmt(it) => &it.syntax, + Stmt::CreateTable(it) => &it.syntax, + Stmt::CreateTableAsStmt(it) => &it.syntax, + Stmt::DeclareStmt(it) => &it.syntax, + Stmt::DeleteStmt(it) => &it.syntax, + Stmt::DropAggregate(it) => &it.syntax, + Stmt::DropDatabase(it) => &it.syntax, + Stmt::DropIndex(it) => &it.syntax, + Stmt::DropTable(it) => &it.syntax, + Stmt::DropType(it) => &it.syntax, + Stmt::ExecuteStmt(it) => &it.syntax, + Stmt::InsertStmt(it) => &it.syntax, + Stmt::MergeStmt(it) => &it.syntax, + Stmt::NotifyStmt(it) => &it.syntax, + Stmt::ReleaseSavepointStmt(it) => &it.syntax, + Stmt::RevokeStmt(it) => &it.syntax, + Stmt::Rollback(it) => &it.syntax, + Stmt::RollbackStmt(it) => &it.syntax, + Stmt::SavepointStmt(it) => &it.syntax, + Stmt::Select(it) => &it.syntax, + Stmt::TableStmt(it) => &it.syntax, + Stmt::TruncateStmt(it) => &it.syntax, + Stmt::UpdateStmt(it) => &it.syntax, + Stmt::Values(it) => &it.syntax, + } + } +} +impl From for Stmt { + #[inline] + fn from(node: AlterAggregate) -> Stmt { + Stmt::AlterAggregate(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: AlterDomain) -> Stmt { + Stmt::AlterDomain(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: AlterTable) -> Stmt { + Stmt::AlterTable(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: Begin) -> Stmt { + Stmt::Begin(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: Commit) -> Stmt { + Stmt::Commit(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: CreateAggregate) -> Stmt { + Stmt::CreateAggregate(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: CreateDomain) -> Stmt { + Stmt::CreateDomain(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: CreateFunc) -> Stmt { + Stmt::CreateFunc(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: CreateIndex) -> Stmt { + Stmt::CreateIndex(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: CreateMaterializedViewStmt) -> Stmt { + Stmt::CreateMaterializedViewStmt(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: CreateTable) -> Stmt { + Stmt::CreateTable(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: CreateTableAsStmt) -> Stmt { + Stmt::CreateTableAsStmt(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: DeclareStmt) -> Stmt { + Stmt::DeclareStmt(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: DeleteStmt) -> Stmt { + Stmt::DeleteStmt(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: DropAggregate) -> Stmt { + Stmt::DropAggregate(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: DropDatabase) -> Stmt { + Stmt::DropDatabase(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: DropIndex) -> Stmt { + Stmt::DropIndex(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: DropTable) -> Stmt { + Stmt::DropTable(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: DropType) -> Stmt { + Stmt::DropType(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: ExecuteStmt) -> Stmt { + Stmt::ExecuteStmt(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: InsertStmt) -> Stmt { + Stmt::InsertStmt(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: MergeStmt) -> Stmt { + Stmt::MergeStmt(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: NotifyStmt) -> Stmt { + Stmt::NotifyStmt(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: ReleaseSavepointStmt) -> Stmt { + Stmt::ReleaseSavepointStmt(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: RevokeStmt) -> Stmt { + Stmt::RevokeStmt(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: Rollback) -> Stmt { + Stmt::Rollback(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: RollbackStmt) -> Stmt { + Stmt::RollbackStmt(node) + } +} +impl From for Stmt { + #[inline] + fn from(node: SavepointStmt) -> Stmt { + Stmt::SavepointStmt(node) + } +} +impl From