diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..e137417e --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +crates/squawk_parser/src/generated/* linguist-generated=true +crates/squawk_syntax/src/ast/generated/* linguist-generated=true 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 5291e7b6..fd5a6f9e 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,10 +3775,14 @@ dependencies = [ "clap 4.5.37", "convert_case", "enum-iterator", + "proc-macro2", + "quote", "regex", "reqwest 0.12.15", "serde", "serde_json", + "ungrammar", + "xshell", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 433617db..c4f73f06 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -46,6 +46,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_linter/src/rules/adding_field_with_default.rs b/crates/squawk_linter/src/rules/adding_field_with_default.rs index fc03201c..55a29a86 100644 --- a/crates/squawk_linter/src/rules/adding_field_with_default.rs +++ b/crates/squawk_linter/src/rules/adding_field_with_default.rs @@ -2,8 +2,8 @@ use lazy_static::lazy_static; use std::collections::HashSet; use squawk_syntax::ast; -use squawk_syntax::ast::{AstNode, HasArgList}; -use squawk_syntax::{ast::HasModuleItem, Parse, SourceFile}; +use squawk_syntax::ast::AstNode; +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..7f461153 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,18 +7,17 @@ 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 { - let actions = alter_domain.actions(); - for action in actions { - if let ast::AlterDomainAction::AddConstraint(add_constraint) = action { - ctx.report(Violation::new( + for stmt in file.stmts() { + if let ast::Stmt::AlterDomain(alter_domain) = stmt { + if let Some(ast::AlterDomainAction::AddConstraint(add_constraint)) = + alter_domain.action() + { + ctx.report(Violation::new( Rule::BanAlterDomainWithAddConstraint, "Domains with constraints have poor support for online migrations. Use table and column constraints instead.".into(), add_constraint.syntax().text_range(), None, )) - } } } } 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..4edaffe5 100644 --- a/crates/squawk_linter/src/rules/ban_truncate_cascade.rs +++ b/crates/squawk_linter/src/rules/ban_truncate_cascade.rs @@ -1,28 +1,22 @@ -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 { - ast::Stmt::Truncate(truncate) => { - if let Some(cascade) = truncate.cascade_token() { - // TODO: if we had knowledge about the entire schema, we - // could be more precise here and actually navigate the - // foreign keys. - ctx.report(Violation::new( - Rule::BanTruncateCascade, - format!("Using `CASCADE` will recursively truncate any tables that foreign key to the referenced tables! So if you had foreign keys setup as `a <- b <- c` and truncated `a`, then `b` & `c` would also be truncated!"), - cascade.text_range(), - "Remove the `CASCADE` and specify exactly which tables you want to truncate.".to_string(), - )); - } + for stmt in file.stmts() { + if let ast::Stmt::Truncate(truncate) = stmt { + if let Some(cascade) = truncate.cascade_token() { + // TODO: if we had knowledge about the entire schema, we + // could be more precise here and actually navigate the + // foreign keys. + ctx.report(Violation::new( + Rule::BanTruncateCascade, + "Using `CASCADE` will recursively truncate any tables that foreign key to the referenced tables! So if you had foreign keys setup as `a <- b <- c` and truncated `a`, then `b` & `c` would also be truncated!".to_string(), + cascade.text_range(), + "Remove the `CASCADE` and specify exactly which tables you want to truncate.".to_string(), + )); } - _ => (), } } } 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..3314da08 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,10 +104,11 @@ 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/prefer_text_field.rs b/crates/squawk_linter/src/rules/prefer_text_field.rs index dc7e5ba5..62e24ec4 100644 --- a/crates/squawk_linter/src/rules/prefer_text_field.rs +++ b/crates/squawk_linter/src/rules/prefer_text_field.rs @@ -1,7 +1,7 @@ use std::collections::HashSet; use squawk_syntax::{ - ast::{self, AstNode, HasArgList}, + ast::{self, AstNode}, Parse, SourceFile, }; diff --git a/crates/squawk_linter/src/rules/prefer_timestamptz.rs b/crates/squawk_linter/src/rules/prefer_timestamptz.rs index f88297f0..efe2ee96 100644 --- a/crates/squawk_linter/src/rules/prefer_timestamptz.rs +++ b/crates/squawk_linter/src/rules/prefer_timestamptz.rs @@ -1,5 +1,5 @@ use squawk_syntax::{ - ast::{self, AstNode, HasArgList}, + ast::{self, AstNode}, Parse, SourceFile, }; 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..81e88528 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,10 +10,11 @@ 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() + .relation_name() + .and_then(|x| x.path()) .and_then(|x| x.segment()) .and_then(|x| x.name_ref()) { 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/snapshots/squawk_linter__rules__adding_field_with_default__test__add_numbers_ok.snap b/crates/squawk_linter/src/rules/snapshots/squawk_linter__rules__adding_field_with_default__test__add_numbers_ok.snap index 5563b6de..6014ae82 100644 --- a/crates/squawk_linter/src/rules/snapshots/squawk_linter__rules__adding_field_with_default__test__add_numbers_ok.snap +++ b/crates/squawk_linter/src/rules/snapshots/squawk_linter__rules__adding_field_with_default__test__add_numbers_ok.snap @@ -2,4 +2,13 @@ source: crates/squawk_linter/src/rules/adding_field_with_default.rs expression: errors --- -[] +[ + Violation { + code: AddingFieldWithDefault, + message: "Adding a generated column requires a table rewrite with an `ACCESS EXCLUSIVE` lock.", + text_range: 62..67, + help: Some( + "Add the column as nullable, backfill existing rows, and add a trigger to update the column on write instead.", + ), + }, +] diff --git a/crates/squawk_linter/src/rules/transaction_nesting.rs b/crates/squawk_linter/src/rules/transaction_nesting.rs index b3abc7d9..337f6a31 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,21 +10,21 @@ 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( Rule::TransactionNesting, "There is an existing transaction already in progress, managed by your migration tool.".to_string(), - item.syntax().text_range(), + stmt.syntax().text_range(), assume_in_transaction_help.to_string() )); } else if in_explicit_transaction { ctx.report(Violation::new( Rule::TransactionNesting, "There is an existing transaction already in progress.".to_string(), - item.syntax().text_range(), + stmt.syntax().text_range(), assume_in_transaction_help.to_string(), )); } @@ -36,14 +36,14 @@ pub(crate) fn transaction_nesting(ctx: &mut Linter, parse: &Parse) { Rule::TransactionNesting, "Attempting to end the transaction that is managed by your migration tool" .to_string(), - item.syntax().text_range(), + stmt.syntax().text_range(), assume_in_transaction_help.to_string(), )); } else if !in_explicit_transaction { ctx.report(Violation::new( Rule::TransactionNesting, "There is no transaction to `COMMIT` or `ROLLBACK`.".to_string(), - item.syntax().text_range(), + stmt.syntax().text_range(), "`BEGIN` a transaction at an earlier point in the migration or remove this statement.".to_string() )); } diff --git a/crates/squawk_linter/src/visitors.rs b/crates/squawk_linter/src/visitors.rs index 2d642e6b..9860180a 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,8 +39,8 @@ 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() { 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..d20421e4 --- /dev/null +++ b/crates/squawk_parser/src/generated/syntax_kind.rs @@ -0,0 +1,1953 @@ +#![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, + ENFORCED_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, + OBJECTS_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, + 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, + 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, + 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, + VIRTUAL_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, + AGGREGATE, + ALIAS, + ALTER_AGGREGATE, + ALTER_COLLATION_STMT, + ALTER_COLUMN, + ALTER_COLUMN_OPTION, + ALTER_CONSTRAINT, + ALTER_CONVERSION_STMT, + ALTER_DATABASE_STMT, + ALTER_DEFAULT_PRIVILEGES_STMT, + ALTER_DOMAIN, + ALTER_DOMAIN_ACTION, + 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_CAST_STMT, + CREATE_COLLATION_STMT, + CREATE_CONVERSION_STMT, + CREATE_DATABASE_STMT, + CREATE_DOMAIN, + CREATE_EVENT_TRIGGER_STMT, + CREATE_EXTENSION_STMT, + CREATE_FOREIGN_DATA_WRAPPER_STMT, + CREATE_FOREIGN_TABLE_STMT, + CREATE_FUNCTION, + 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_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_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, + 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, + 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("enforced") { + SyntaxKind::ENFORCED_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("objects") { + SyntaxKind::OBJECTS_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("virtual") { + SyntaxKind::VIRTUAL_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..e7c441a9 --- /dev/null +++ b/crates/squawk_parser/src/generated/token_sets.rs @@ -0,0 +1,2186 @@ +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::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::ENFORCED_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::OBJECTS_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::VIRTUAL_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::ENFORCED_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::OBJECTS_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::VIRTUAL_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::ENFORCED_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::OBJECTS_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::VIRTUAL_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::ENFORCED_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::OBJECTS_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::VIRTUAL_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::ENFORCED_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::OBJECTS_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::VIRTUAL_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, +]); diff --git a/crates/squawk_parser/src/grammar.rs b/crates/squawk_parser/src/grammar.rs index 65377c4a..94ff3a74 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, }; @@ -2095,7 +2095,7 @@ fn current_op(p: &Parser<'_>, r: &Restrictions) -> (u8, SyntaxKind, Associativit // 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), @@ -4097,7 +4097,6 @@ 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, @@ -4710,7 +4709,7 @@ fn rollback_stmt(p: &mut Parser<'_>) -> CompletedMarker { p.bump_any(); if p.eat(PREPARED_KW) { string_literal(p); - return m.complete(p, ROLLBACK_STMT); + return m.complete(p, ROLLBACK); } let _ = p.eat(WORK_KW) || p.eat(TRANSACTION_KW); if is_rollback && p.eat(TO_KW) { @@ -4722,7 +4721,7 @@ fn rollback_stmt(p: &mut Parser<'_>) -> CompletedMarker { p.eat(NO_KW); p.expect(CHAIN_KW); } - m.complete(p, ROLLBACK_STMT) + m.complete(p, ROLLBACK) } struct StmtRestrictions { @@ -6205,8 +6204,7 @@ fn alter_extension_stmt(p: &mut Parser<'_>) -> CompletedMarker { } AGGREGATE_KW => { p.bump(AGGREGATE_KW); - path_name_ref(p); - aggregate_arg_list(p); + aggregate(p); } CAST_KW => { p.bump(CAST_KW); @@ -6340,7 +6338,7 @@ fn alter_domain_stmt(p: &mut Parser<'_>) -> CompletedMarker { p.bump(DOMAIN_KW); path_name_ref(p); alter_domain_action(p); - m.complete(p, ALTER_DOMAIN_STMT) + m.complete(p, ALTER_DOMAIN) } fn alter_domain_action(p: &mut Parser<'_>) -> Option { @@ -6744,8 +6742,7 @@ fn alter_aggregate_stmt(p: &mut Parser<'_>) -> CompletedMarker { let m = p.start(); p.bump(ALTER_KW); p.bump(AGGREGATE_KW); - path_name_ref(p); - aggregate_arg_list(p); + aggregate(p); match p.current() { RENAME_KW => { p.bump(RENAME_KW); @@ -6766,7 +6763,7 @@ fn alter_aggregate_stmt(p: &mut Parser<'_>) -> CompletedMarker { p.error("expected RENAME, OWNER, or SET"); } } - m.complete(p, ALTER_AGGREGATE_STMT) + m.complete(p, ALTER_AGGREGATE) } // ALTER SUBSCRIPTION name CONNECTION 'conninfo' @@ -7547,8 +7544,7 @@ fn comment_stmt(p: &mut Parser<'_>) -> CompletedMarker { } AGGREGATE_KW => { p.bump_any(); - path_name_ref(p); - aggregate_arg_list(p); + aggregate(p); } CAST_KW => { p.bump_any(); @@ -7792,7 +7788,7 @@ fn create_aggregate_stmt(p: &mut Parser<'_>) -> CompletedMarker { } } p.expect(R_PAREN); - m.complete(p, CREATE_AGGREGATE_STMT) + m.complete(p, CREATE_AGGREGATE) } // CREATE CAST (source_type AS target_type) @@ -7974,7 +7970,7 @@ fn create_domain_stmt(p: &mut Parser<'_>) -> CompletedMarker { break; } } - m.complete(p, CREATE_DOMAIN_STMT) + m.complete(p, CREATE_DOMAIN) } // filter_variable IN (filter_value [, ... ]) @@ -9149,7 +9145,7 @@ fn aggregate(p: &mut Parser<'_>) { let m = p.start(); path_name_ref(p); aggregate_arg_list(p); - m.complete(p, CALL_EXPR); + m.complete(p, AGGREGATE); } // DROP AGGREGATE [ IF EXISTS ] name ( aggregate_signature ) [, ...] [ CASCADE | RESTRICT ] @@ -10411,8 +10407,7 @@ fn security_label_stmt(p: &mut Parser<'_>) -> CompletedMarker { } AGGREGATE_KW => { p.bump(AGGREGATE_KW); - path_name(p); - aggregate_arg_list(p); + aggregate(p); } _ => p.error("expected database object name"), } @@ -11040,7 +11035,7 @@ fn truncate_stmt(p: &mut Parser<'_>) -> CompletedMarker { p.expect(IDENTITY_KW); } opt_cascade_or_restrict(p); - m.complete(p, TRUNCATE_STMT) + m.complete(p, TRUNCATE) } // VACUUM [ ( option [, ...] ) ] [ table_and_columns [, ...] ] @@ -11452,16 +11447,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 } @@ -11904,7 +11891,7 @@ fn drop_index_stmt(p: &mut Parser<'_>) -> CompletedMarker { } } opt_cascade_or_restrict(p); - m.complete(p, DROP_INDEX_STMT) + m.complete(p, DROP_INDEX) } // DROP DATABASE [ IF EXISTS ] name [ [ WITH ] ( option [, ...] ) ] @@ -11931,7 +11918,7 @@ fn drop_database_stmt(p: &mut Parser<'_>) -> CompletedMarker { } p.expect(R_PAREN); } - m.complete(p, DROP_DATABASE_STMT) + m.complete(p, DROP_DATABASE) } // CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] [ [ IF NOT EXISTS ] name ] ON [ ONLY ] table_name [ USING method ] @@ -12064,6 +12051,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(); @@ -12472,7 +12460,7 @@ fn create_function_stmt(p: &mut Parser<'_>) -> CompletedMarker { param_list(p); opt_ret_type(p); func_option_list(p); - m.complete(p, CREATE_FUNCTION_STMT) + m.complete(p, CREATE_FUNCTION) } fn opt_or_replace(p: &mut Parser<'_>) -> Option { @@ -12694,7 +12682,7 @@ const NON_RESERVED_WORD: TokenSet = TokenSet::new(&[IDENT]) .union(TYPE_FUNC_NAME_KEYWORDS); fn relation_name(p: &mut Parser<'_>) { - // [ ONLY ] + let m = p.start(); if p.eat(ONLY_KW) { let trailing_paren = p.eat(L_PAREN); // name @@ -12706,6 +12694,7 @@ fn relation_name(p: &mut Parser<'_>) { path_name_ref(p); p.eat(STAR); } + m.complete(p, RELATION_NAME); } // ALTER TABLE [ IF EXISTS ] [ ONLY ] name [ * ] @@ -12984,9 +12973,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/lib.rs b/crates/squawk_parser/src/lib.rs index d97b0ad6..f81a1f56 100644 --- a/crates/squawk_parser/src/lib.rs +++ b/crates/squawk_parser/src/lib.rs @@ -49,16 +49,15 @@ 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; +mod token_set; pub use crate::{ lexed_str::LexedStr, diff --git a/crates/squawk_parser/src/syntax_kind.rs b/crates/squawk_parser/src/syntax_kind.rs index 4b5aa0e4..9c3e4980 100644 --- a/crates/squawk_parser/src/syntax_kind.rs +++ b/crates/squawk_parser/src/syntax_kind.rs @@ -1,1507 +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, - /// `::` - COLON_COLON, - /// `:=` - COLON_EQ, - /// `=` - 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, - /// `enforced` - ENFORCED_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, - /// `objects` - OBJECTS_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, - /// `virtual` - VIRTUAL_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, - POSITIONAL_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, - 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, - CREATE_TYPE_STMT, - CREATE_TRIGGER_STMT, - CREATE_FUNCTION_STMT, - PARAM, - PARAM_IN, - PARAM_OUT, - PARAM_IN_OUT, - 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, - 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, - 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, - INITIALLY_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] @@ -1523,3187 +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("enforced") { - SyntaxKind::ENFORCED_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("objects") { - SyntaxKind::OBJECTS_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("virtual") { - SyntaxKind::VIRTUAL_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::ENFORCED_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::OBJECTS_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::VIRTUAL_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::ENFORCED_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::OBJECTS_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::VIRTUAL_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::ENFORCED_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::OBJECTS_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::VIRTUAL_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::ENFORCED_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::OBJECTS_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::VIRTUAL_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::ENFORCED_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::OBJECTS_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::VIRTUAL_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/tests/snapshots/tests__alter_aggregate_ok.snap b/crates/squawk_parser/tests/snapshots/tests__alter_aggregate_ok.snap index ed5750e3..cf9c0700 100644 --- a/crates/squawk_parser/tests/snapshots/tests__alter_aggregate_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__alter_aggregate_ok.snap @@ -6,20 +6,21 @@ snapshot_kind: text SOURCE_FILE COMMENT "-- star" WHITESPACE "\n" - ALTER_AGGREGATE_STMT + ALTER_AGGREGATE ALTER_KW "alter" WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" - WHITESPACE " " - PARAM_LIST - L_PAREN "(" - STAR "*" - R_PAREN ")" + AGGREGATE + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" + WHITESPACE " " + PARAM_LIST + L_PAREN "(" + STAR "*" + R_PAREN ")" WHITESPACE " " RENAME_KW "rename" WHITESPACE " " @@ -33,22 +34,23 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- simple_args" WHITESPACE "\n" - ALTER_AGGREGATE_STMT + ALTER_AGGREGATE ALTER_KW "alter" WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" - WHITESPACE " " - PARAM_LIST - L_PAREN "(" - PARAM - PATH_TYPE - IDENT "t" - R_PAREN ")" + AGGREGATE + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" + WHITESPACE " " + PARAM_LIST + L_PAREN "(" + PARAM + PATH_TYPE + IDENT "t" + R_PAREN ")" WHITESPACE " " SET_KW "set" WHITESPACE " " @@ -62,42 +64,43 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- complex_args" WHITESPACE "\n" - ALTER_AGGREGATE_STMT + ALTER_AGGREGATE ALTER_KW "alter" WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" - WHITESPACE " " - PARAM_LIST - L_PAREN "(" - PARAM - PARAM_IN - IN_KW "in" - WHITESPACE " " - NAME - IDENT "x" - WHITESPACE " " - PATH_TYPE - PATH - PATH_SEGMENT - NAME_REF - TEXT_KW "text" - COMMA "," + AGGREGATE + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" WHITESPACE " " - PARAM - NAME - IDENT "y" + PARAM_LIST + L_PAREN "(" + PARAM + PARAM_IN + IN_KW "in" + WHITESPACE " " + NAME + IDENT "x" + WHITESPACE " " + PATH_TYPE + PATH + PATH_SEGMENT + NAME_REF + TEXT_KW "text" + COMMA "," WHITESPACE " " - PATH_TYPE - PATH - PATH_SEGMENT - NAME_REF - NUMERIC_KW "numeric" - R_PAREN ")" + PARAM + NAME + IDENT "y" + WHITESPACE " " + PATH_TYPE + PATH + PATH_SEGMENT + NAME_REF + NUMERIC_KW "numeric" + R_PAREN ")" WHITESPACE " \n " OWNER_KW "owner" WHITESPACE " " @@ -108,30 +111,31 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- with_order_by" WHITESPACE "\n" - ALTER_AGGREGATE_STMT + ALTER_AGGREGATE ALTER_KW "alter" WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" - WHITESPACE " " - PARAM_LIST - L_PAREN "(" - PARAM - PATH_TYPE - IDENT "x" - WHITESPACE " " - ORDER_KW "order" - WHITESPACE " " - BY_KW "by" + AGGREGATE + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" WHITESPACE " " - PARAM - PATH_TYPE - IDENT "y" - R_PAREN ")" + PARAM_LIST + L_PAREN "(" + PARAM + PATH_TYPE + IDENT "x" + WHITESPACE " " + ORDER_KW "order" + WHITESPACE " " + BY_KW "by" + WHITESPACE " " + PARAM + PATH_TYPE + IDENT "y" + R_PAREN ")" WHITESPACE " \n " RENAME_KW "rename" WHITESPACE " " @@ -145,35 +149,36 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- qualified_names" WHITESPACE "\n" - ALTER_AGGREGATE_STMT + ALTER_AGGREGATE ALTER_KW "alter" WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH + AGGREGATE PATH + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" + DOT "." PATH_SEGMENT NAME_REF - IDENT "foo" - DOT "." - PATH_SEGMENT - NAME_REF - IDENT "bar" - WHITESPACE " " - PARAM_LIST - L_PAREN "(" - PARAM - PARAM_IN - IN_KW "in" - WHITESPACE " " - PATH_TYPE - IDENT "t" - COMMA "," + IDENT "bar" WHITESPACE " " - PARAM - PATH_TYPE - IDENT "u" - R_PAREN ")" + PARAM_LIST + L_PAREN "(" + PARAM + PARAM_IN + IN_KW "in" + WHITESPACE " " + PATH_TYPE + IDENT "t" + COMMA "," + WHITESPACE " " + PARAM + PATH_TYPE + IDENT "u" + R_PAREN ")" WHITESPACE " \n " SET_KW "set" WHITESPACE " " diff --git a/crates/squawk_parser/tests/snapshots/tests__alter_domain_ok.snap b/crates/squawk_parser/tests/snapshots/tests__alter_domain_ok.snap index 3c364b47..986981ff 100644 --- a/crates/squawk_parser/tests/snapshots/tests__alter_domain_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__alter_domain_ok.snap @@ -6,7 +6,7 @@ snapshot_kind: text SOURCE_FILE COMMENT "-- set_default" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -27,7 +27,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- drop_default" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -50,7 +50,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- set_not_null" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -70,7 +70,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- drop_not_null" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -90,7 +90,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- add_constraint" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -123,7 +123,7 @@ SOURCE_FILE R_PAREN ")" SEMICOLON ";" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -155,7 +155,7 @@ SOURCE_FILE VALID_KW "valid" SEMICOLON ";" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -190,7 +190,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- drop_constraint" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -211,7 +211,7 @@ SOURCE_FILE CASCADE_KW "cascade" SEMICOLON ";" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -239,7 +239,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- rename_constraint" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -265,7 +265,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- validate_constraint" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -286,7 +286,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- owner_to" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -304,7 +304,7 @@ SOURCE_FILE IDENT "u" SEMICOLON ";" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -324,7 +324,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- rename_to" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" @@ -345,7 +345,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- set_schema" WHITESPACE "\n" - ALTER_DOMAIN_STMT + ALTER_DOMAIN ALTER_KW "alter" WHITESPACE " " DOMAIN_KW "domain" diff --git a/crates/squawk_parser/tests/snapshots/tests__alter_extension_ok.snap b/crates/squawk_parser/tests/snapshots/tests__alter_extension_ok.snap index 3bccc061..688053c2 100644 --- a/crates/squawk_parser/tests/snapshots/tests__alter_extension_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__alter_extension_ok.snap @@ -118,41 +118,42 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" - WHITESPACE " " - PARAM_LIST - L_PAREN "(" + AGGREGATE + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" WHITESPACE " " - PARAM - PARAM_IN - IN_KW "in" + PARAM_LIST + L_PAREN "(" WHITESPACE " " - NAME - IDENT "a" + PARAM + PARAM_IN + IN_KW "in" + WHITESPACE " " + NAME + IDENT "a" + WHITESPACE " " + PATH_TYPE + PATH + PATH_SEGMENT + NAME_REF + TEXT_KW "text" WHITESPACE " " - PATH_TYPE - PATH - PATH_SEGMENT - NAME_REF - TEXT_KW "text" - WHITESPACE " " - ORDER_KW "order" - WHITESPACE " " - BY_KW "by" - WHITESPACE " " - PARAM - PATH_TYPE - IDENT "b" - COMMA "," - WHITESPACE " " - PARAM - PATH_TYPE - IDENT "c" - WHITESPACE " " - R_PAREN ")" + ORDER_KW "order" + WHITESPACE " " + BY_KW "by" + WHITESPACE " " + PARAM + PATH_TYPE + IDENT "b" + COMMA "," + WHITESPACE " " + PARAM + PATH_TYPE + IDENT "c" + WHITESPACE " " + R_PAREN ")" SEMICOLON ";" WHITESPACE "\n" ALTER_EXTENSION_STMT @@ -167,15 +168,16 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" - WHITESPACE " " - PARAM_LIST - L_PAREN "(" - STAR "*" - R_PAREN ")" + AGGREGATE + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" + WHITESPACE " " + PARAM_LIST + L_PAREN "(" + STAR "*" + R_PAREN ")" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- add_drop_cast" diff --git a/crates/squawk_parser/tests/snapshots/tests__alter_foreign_table_ok.snap b/crates/squawk_parser/tests/snapshots/tests__alter_foreign_table_ok.snap index c9f3f04a..bb06c85f 100644 --- a/crates/squawk_parser/tests/snapshots/tests__alter_foreign_table_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__alter_foreign_table_ok.snap @@ -13,10 +13,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " RENAME_KW "rename" WHITESPACE " " @@ -35,12 +36,13 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " RENAME_KW "rename" WHITESPACE " " @@ -57,12 +59,13 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" - WHITESPACE " " - STAR "*" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" + WHITESPACE " " + STAR "*" WHITESPACE "\n " RENAME_KW "rename" WHITESPACE " " @@ -81,10 +84,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " RENAME_KW "rename" WHITESPACE " " @@ -106,10 +110,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " RENAME_KW "rename" WHITESPACE " " @@ -131,15 +136,16 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH + RELATION_NAME PATH + PATH + PATH_SEGMENT + NAME_REF + IDENT "f" + DOT "." PATH_SEGMENT NAME_REF - IDENT "f" - DOT "." - PATH_SEGMENT - NAME_REF - IDENT "t" + IDENT "t" WHITESPACE "\n " SET_KW "set" WHITESPACE " " @@ -158,10 +164,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ADD_COLUMN ADD_KW "add" @@ -185,10 +192,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ADD_COLUMN ADD_KW "add" @@ -239,10 +247,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " DROP_COLUMN DROP_KW "drop" @@ -260,10 +269,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " DROP_COLUMN DROP_KW "drop" @@ -288,10 +298,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " DROP_COLUMN DROP_KW "drop" @@ -318,10 +329,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -347,10 +359,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -390,10 +403,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -424,10 +438,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -458,10 +473,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -483,10 +499,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -508,10 +525,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -535,10 +553,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -562,10 +581,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -590,10 +610,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -618,10 +639,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -655,10 +677,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -692,10 +715,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -724,10 +748,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -752,10 +777,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -779,10 +805,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -804,10 +831,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -829,10 +857,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -854,10 +883,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -881,10 +911,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -935,10 +966,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ALTER_COLUMN ALTER_KW "alter" @@ -967,10 +999,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ADD_CONSTRAINT ADD_KW "add" @@ -1007,10 +1040,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ADD_CONSTRAINT ADD_KW "add" @@ -1044,10 +1078,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " VALIDATE_CONSTRAINT VALIDATE_KW "validate" @@ -1067,10 +1102,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " DROP_CONSTRAINT DROP_KW "drop" @@ -1095,10 +1131,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " DROP_CONSTRAINT DROP_KW "drop" @@ -1120,10 +1157,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " DISABLE_TRIGGER DISABLE_KW "disable" @@ -1141,10 +1179,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " DISABLE_TRIGGER DISABLE_KW "disable" @@ -1161,10 +1200,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " DISABLE_TRIGGER DISABLE_KW "disable" @@ -1183,10 +1223,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ENABLE_REPLICA_TRIGGER ENABLE_KW "enable" @@ -1208,10 +1249,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ENABLE_ALWAYS_TRIGGER ENABLE_KW "enable" @@ -1233,10 +1275,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " SET_WITHOUT_OIDS SET_KW "set" @@ -1255,10 +1298,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " INHERIT INHERIT_KW "inherit" @@ -1276,15 +1320,16 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH + RELATION_NAME PATH + PATH + PATH_SEGMENT + NAME_REF + IDENT "s" + DOT "." PATH_SEGMENT NAME_REF - IDENT "s" - DOT "." - PATH_SEGMENT - NAME_REF - IDENT "t" + IDENT "t" WHITESPACE "\n " INHERIT INHERIT_KW "inherit" @@ -1309,10 +1354,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " NO_INHERIT NO_KW "no" @@ -1332,15 +1378,16 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH + RELATION_NAME PATH + PATH + PATH_SEGMENT + NAME_REF + IDENT "s" + DOT "." PATH_SEGMENT NAME_REF - IDENT "s" - DOT "." - PATH_SEGMENT - NAME_REF - IDENT "t" + IDENT "t" WHITESPACE "\n " NO_INHERIT NO_KW "no" @@ -1367,18 +1414,18 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " OWNER_TO OWNER_KW "owner" WHITESPACE " " TO_KW "to" WHITESPACE " " - NAME_REF - IDENT "u" + IDENT "u" SEMICOLON ";" WHITESPACE "\n\n" ALTER_FOREIGN_TABLE_STMT @@ -1388,10 +1435,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " OWNER_TO OWNER_KW "owner" @@ -1410,10 +1458,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " ADD_COLUMN ADD_KW "add" @@ -1470,17 +1519,17 @@ SOURCE_FILE WHITESPACE " " EXISTS_KW "exists" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " OWNER_TO OWNER_KW "owner" WHITESPACE " " TO_KW "to" WHITESPACE " " - NAME_REF - IDENT "u" + IDENT "u" SEMICOLON ";" WHITESPACE "\n\n" diff --git a/crates/squawk_parser/tests/snapshots/tests__alter_table_err.snap b/crates/squawk_parser/tests/snapshots/tests__alter_table_err.snap index 2900c5ed..25b35d60 100644 --- a/crates/squawk_parser/tests/snapshots/tests__alter_table_err.snap +++ b/crates/squawk_parser/tests/snapshots/tests__alter_table_err.snap @@ -26,10 +26,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_CONSTRAINT ALTER_KW "alter" @@ -58,15 +59,16 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH + RELATION_NAME PATH + PATH + PATH_SEGMENT + NAME_REF + IDENT "public" + DOT "." PATH_SEGMENT NAME_REF - IDENT "public" - DOT "." - PATH_SEGMENT - NAME_REF - IDENT "copy_2" + IDENT "copy_2" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" diff --git a/crates/squawk_parser/tests/snapshots/tests__alter_table_ok.snap b/crates/squawk_parser/tests/snapshots/tests__alter_table_ok.snap index 850398bc..0f2e452a 100644 --- a/crates/squawk_parser/tests/snapshots/tests__alter_table_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__alter_table_ok.snap @@ -11,10 +11,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ADD_COLUMN ADD_KW "add" @@ -38,10 +39,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -78,10 +80,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_CONSTRAINT ALTER_KW "alter" @@ -97,10 +100,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_CONSTRAINT ALTER_KW "alter" @@ -120,10 +124,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_CONSTRAINT ALTER_KW "alter" @@ -145,10 +150,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_CONSTRAINT ALTER_KW "alter" @@ -177,10 +183,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " VALIDATE_CONSTRAINT VALIDATE_KW "validate" @@ -198,10 +205,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -226,10 +234,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -251,10 +260,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -299,10 +309,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -324,10 +335,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -354,10 +366,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -375,10 +388,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -398,10 +412,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -421,10 +436,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -442,10 +458,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -468,10 +485,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -497,10 +515,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -524,10 +543,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -565,10 +585,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -605,10 +626,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -647,10 +669,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -668,10 +691,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -694,10 +718,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -718,10 +743,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -764,10 +790,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -798,10 +825,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -835,10 +863,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -900,10 +929,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -923,10 +953,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -946,10 +977,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -969,10 +1001,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -992,10 +1025,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -1015,10 +1049,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -1038,10 +1073,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -1061,10 +1097,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -1083,10 +1120,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " INHERIT INHERIT_KW "inherit" @@ -1102,10 +1140,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " NO_INHERIT NO_KW "no" @@ -1125,10 +1164,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " DROP_CONSTRAINT DROP_KW "drop" @@ -1146,10 +1186,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -1173,10 +1214,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " DROP_CONSTRAINT DROP_KW "drop" @@ -1197,10 +1239,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " DROP_CONSTRAINT DROP_KW "drop" @@ -1223,10 +1266,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " DROP_CONSTRAINT DROP_KW "drop" @@ -1251,10 +1295,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " DISABLE_TRIGGER DISABLE_KW "disable" @@ -1270,10 +1315,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " DISABLE_TRIGGER DISABLE_KW "disable" @@ -1288,10 +1334,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " DISABLE_TRIGGER DISABLE_KW "disable" @@ -1308,10 +1355,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ENABLE_TRIGGER ENABLE_KW "enable" @@ -1327,10 +1375,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ENABLE_TRIGGER ENABLE_KW "enable" @@ -1345,10 +1394,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ENABLE_TRIGGER ENABLE_KW "enable" @@ -1363,10 +1413,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ENABLE_REPLICA_TRIGGER ENABLE_KW "enable" @@ -1384,10 +1435,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ENABLE_ALWAYS_TRIGGER ENABLE_KW "enable" @@ -1407,10 +1459,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " REPLICA_IDENTITY REPLICA_KW "replica" @@ -1425,10 +1478,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " REPLICA_IDENTITY REPLICA_KW "replica" @@ -1448,10 +1502,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " REPLICA_IDENTITY REPLICA_KW "replica" @@ -1466,10 +1521,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " REPLICA_IDENTITY REPLICA_KW "replica" @@ -1486,10 +1542,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " DISABLE_RULE DISABLE_KW "disable" @@ -1505,10 +1562,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ENABLE_RULE ENABLE_KW "enable" @@ -1524,10 +1582,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ENABLE_REPLICA_RULE ENABLE_KW "enable" @@ -1545,10 +1604,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ENABLE_ALWAYS_RULE ENABLE_KW "enable" @@ -1568,10 +1628,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " DISABLE_RLS DISABLE_KW "disable" @@ -1588,10 +1649,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ENABLE_RLS ENABLE_KW "enable" @@ -1608,10 +1670,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " FORCE_RLS FORCE_KW "force" @@ -1628,10 +1691,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " NO_FORCE_RLS NO_KW "no" @@ -1652,10 +1716,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " CLUSTER_ON CLUSTER_KW "cluster" @@ -1671,10 +1736,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " SET_WITHOUT_CLUSTER SET_KW "set" @@ -1689,10 +1755,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " SET_WITHOUT_OIDS SET_KW "set" @@ -1709,10 +1776,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " SET_ACCESS_METHOD SET_KW "set" @@ -1730,10 +1798,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " SET_LOGGED SET_KW "set" @@ -1746,10 +1815,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " SET_UNLOGGED SET_KW "set" @@ -1764,10 +1834,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " OF_TYPE OF_KW "of" @@ -1784,10 +1855,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " NOT_OF NOT_KW "not" @@ -1802,10 +1874,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ADD_COLUMN ADD_KW "add" @@ -1843,10 +1916,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -1870,10 +1944,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ADD_COLUMN ADD_KW "add" @@ -1914,10 +1989,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -1959,10 +2035,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " DROP_COLUMN DROP_KW "drop" @@ -1980,10 +2057,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " DROP_COLUMN DROP_KW "drop" @@ -2003,10 +2081,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " DROP_COLUMN DROP_KW "drop" @@ -2026,10 +2105,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " DROP_COLUMN DROP_KW "drop" @@ -2045,10 +2125,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " DROP_COLUMN DROP_KW "drop" @@ -2071,10 +2152,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2099,10 +2181,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2128,10 +2211,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2194,10 +2278,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2225,10 +2310,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2291,10 +2377,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2340,10 +2427,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2409,10 +2497,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2447,10 +2536,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2489,10 +2579,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2531,10 +2622,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2597,10 +2689,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2638,10 +2731,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2677,10 +2771,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2716,10 +2811,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2757,10 +2853,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2810,10 +2907,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2851,10 +2949,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2901,10 +3000,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2936,10 +3036,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2961,10 +3062,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -2988,10 +3090,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -3018,10 +3121,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -3052,10 +3156,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" @@ -3095,10 +3200,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " RENAME_COLUMN RENAME_KW "rename" @@ -3124,12 +3230,13 @@ SOURCE_FILE WHITESPACE " " EXISTS_KW "exists" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n" RENAME_COLUMN RENAME_KW "rename" @@ -3150,12 +3257,13 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" - WHITESPACE " " - STAR "*" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" + WHITESPACE " " + STAR "*" WHITESPACE " \n" RENAME_COLUMN RENAME_KW "rename" @@ -3178,10 +3286,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " RENAME_TABLE RENAME_KW "rename" @@ -3197,14 +3306,15 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - L_PAREN "(" - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" - R_PAREN ")" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + L_PAREN "(" + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" + R_PAREN ")" WHITESPACE " " RENAME_TABLE RENAME_KW "rename" @@ -3222,10 +3332,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " RENAME_CONSTRAINT RENAME_KW "rename" @@ -3248,10 +3359,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " SET_SCHEMA SET_KW "set" @@ -3275,10 +3387,11 @@ SOURCE_FILE WHITESPACE " " TABLESPACE_KW "tablespace" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "foo" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" WHITESPACE " " SET_TABLESPACE SET_KW "set" @@ -3302,10 +3415,11 @@ SOURCE_FILE WHITESPACE " " TABLESPACE_KW "tablespace" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "foo" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" WHITESPACE " " OWNED_KW "owned" WHITESPACE " " @@ -3346,10 +3460,11 @@ SOURCE_FILE WHITESPACE " " TABLESPACE_KW "tablespace" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "foo" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" WHITESPACE " " OWNED_KW "owned" WHITESPACE " " @@ -3372,10 +3487,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " SET_TABLESPACE SET_KW "set" @@ -3393,18 +3509,18 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "table_name" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "table_name" WHITESPACE " " OWNER_TO OWNER_KW "owner" WHITESPACE " " TO_KW "to" WHITESPACE " " - NAME_REF - IDENT "new_owner" + IDENT "new_owner" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- default" @@ -3414,10 +3530,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ATTACH_PARTITION ATTACH_KW "attach" @@ -3437,10 +3554,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ATTACH_PARTITION ATTACH_KW "attach" @@ -3473,10 +3591,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " NOT_OF NOT_KW "not" @@ -3509,10 +3628,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "TABLE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "transactions" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "transactions" WHITESPACE "\n " ADD_COLUMN ADD_KW "ADD" @@ -3561,10 +3681,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " DETACH_PARTITION DETACH_KW "detach" @@ -3582,10 +3703,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " DETACH_PARTITION DETACH_KW "detach" @@ -3605,10 +3727,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " DETACH_PARTITION DETACH_KW "detach" @@ -3628,10 +3751,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "foo" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" WHITESPACE "\n " ADD_CONSTRAINT ADD_KW "add" diff --git a/crates/squawk_parser/tests/snapshots/tests__alter_table_pg17_ok.snap b/crates/squawk_parser/tests/snapshots/tests__alter_table_pg17_ok.snap index 721ae827..0aac3d63 100644 --- a/crates/squawk_parser/tests/snapshots/tests__alter_table_pg17_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__alter_table_pg17_ok.snap @@ -10,10 +10,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALTER_COLUMN ALTER_KW "alter" @@ -46,10 +47,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " SET_ACCESS_METHOD SET_KW "set" @@ -66,10 +68,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ADD_CONSTRAINT ADD_KW "add" diff --git a/crates/squawk_parser/tests/snapshots/tests__comment_ok.snap b/crates/squawk_parser/tests/snapshots/tests__comment_ok.snap index 04bb439f..8b1a6df9 100644 --- a/crates/squawk_parser/tests/snapshots/tests__comment_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__comment_ok.snap @@ -35,15 +35,16 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "my_agg" - WHITESPACE " " - PARAM_LIST - L_PAREN "(" - STAR "*" - R_PAREN ")" + AGGREGATE + PATH + PATH_SEGMENT + NAME_REF + IDENT "my_agg" + WHITESPACE " " + PARAM_LIST + L_PAREN "(" + STAR "*" + R_PAREN ")" WHITESPACE " " IS_KW "is" WHITESPACE " " @@ -60,15 +61,16 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" - WHITESPACE " " - PARAM_LIST - L_PAREN "(" - STAR "*" - R_PAREN ")" + AGGREGATE + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" + WHITESPACE " " + PARAM_LIST + L_PAREN "(" + STAR "*" + R_PAREN ")" WHITESPACE " " IS_KW "is" WHITESPACE " " @@ -85,31 +87,32 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" - WHITESPACE " " - PARAM_LIST - L_PAREN "(" - PARAM - PARAM_IN - IN_KW "in" - WHITESPACE " " - NAME - IDENT "a" - WHITESPACE " " - PATH_TYPE - PATH - PATH_SEGMENT - NAME_REF - TEXT_KW "text" - COMMA "," + AGGREGATE + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" WHITESPACE " " - PARAM - PATH_TYPE - TEXT_KW "text" - R_PAREN ")" + PARAM_LIST + L_PAREN "(" + PARAM + PARAM_IN + IN_KW "in" + WHITESPACE " " + NAME + IDENT "a" + WHITESPACE " " + PATH_TYPE + PATH + PATH_SEGMENT + NAME_REF + TEXT_KW "text" + COMMA "," + WHITESPACE " " + PARAM + PATH_TYPE + TEXT_KW "text" + R_PAREN ")" WHITESPACE " " IS_KW "is" WHITESPACE " " @@ -126,34 +129,35 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" - WHITESPACE " " - PARAM_LIST - L_PAREN "(" - PARAM - PATH_TYPE - PATH - PATH_SEGMENT - NAME_REF - INT_KW "int" - COMMA "," - WHITESPACE " " - PARAM - PATH_TYPE - TEXT_KW "text" - WHITESPACE " " - ORDER_KW "order" - WHITESPACE " " - BY_KW "by" - WHITESPACE " " - PARAM - TIME_TYPE + AGGREGATE + PATH + PATH_SEGMENT NAME_REF - TIMESTAMP_KW "timestamp" - R_PAREN ")" + IDENT "a" + WHITESPACE " " + PARAM_LIST + L_PAREN "(" + PARAM + PATH_TYPE + PATH + PATH_SEGMENT + NAME_REF + INT_KW "int" + COMMA "," + WHITESPACE " " + PARAM + PATH_TYPE + TEXT_KW "text" + WHITESPACE " " + ORDER_KW "order" + WHITESPACE " " + BY_KW "by" + WHITESPACE " " + PARAM + TIME_TYPE + NAME_REF + TIMESTAMP_KW "timestamp" + R_PAREN ")" WHITESPACE " " IS_KW "is" WHITESPACE " " diff --git a/crates/squawk_parser/tests/snapshots/tests__create_aggregate_ok.snap b/crates/squawk_parser/tests/snapshots/tests__create_aggregate_ok.snap index 419cb142..c6dca528 100644 --- a/crates/squawk_parser/tests/snapshots/tests__create_aggregate_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__create_aggregate_ok.snap @@ -6,7 +6,7 @@ snapshot_kind: text SOURCE_FILE COMMENT "-- simple_old_syntax" WHITESPACE "\n" - CREATE_AGGREGATE_STMT + CREATE_AGGREGATE CREATE_KW "create" WHITESPACE " " AGGREGATE_KW "aggregate" @@ -58,7 +58,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- full_old_syntax" WHITESPACE "\n" - CREATE_AGGREGATE_STMT + CREATE_AGGREGATE CREATE_KW "create" WHITESPACE " " OR_REPLACE @@ -357,7 +357,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- simple" WHITESPACE "\n" - CREATE_AGGREGATE_STMT + CREATE_AGGREGATE CREATE_KW "create" WHITESPACE " " AGGREGATE_KW "aggregate" @@ -403,7 +403,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- full" WHITESPACE "\n" - CREATE_AGGREGATE_STMT + CREATE_AGGREGATE CREATE_KW "create" WHITESPACE " " OR_REPLACE @@ -665,7 +665,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- ordered_aggregate" WHITESPACE "\n" - CREATE_AGGREGATE_STMT + CREATE_AGGREGATE CREATE_KW "create" WHITESPACE " " OR_REPLACE @@ -822,7 +822,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- doc_example_1" WHITESPACE "\n" - CREATE_AGGREGATE_STMT + CREATE_AGGREGATE CREATE_KW "CREATE" WHITESPACE " " AGGREGATE_KW "AGGREGATE" @@ -878,7 +878,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- doc_example_2" WHITESPACE "\n" - CREATE_AGGREGATE_STMT + CREATE_AGGREGATE CREATE_KW "CREATE" WHITESPACE " " AGGREGATE_KW "AGGREGATE" @@ -941,7 +941,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- doc_example_3" WHITESPACE "\n" - CREATE_AGGREGATE_STMT + CREATE_AGGREGATE CREATE_KW "CREATE" WHITESPACE " " AGGREGATE_KW "AGGREGATE" @@ -1012,7 +1012,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- doc_example_4" WHITESPACE "\n" - CREATE_AGGREGATE_STMT + CREATE_AGGREGATE CREATE_KW "CREATE" WHITESPACE " " AGGREGATE_KW "AGGREGATE" @@ -1113,7 +1113,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- doc_example_5" WHITESPACE "\n" - CREATE_AGGREGATE_STMT + CREATE_AGGREGATE CREATE_KW "CREATE" WHITESPACE " " AGGREGATE_KW "AGGREGATE" diff --git a/crates/squawk_parser/tests/snapshots/tests__create_domain_ok.snap b/crates/squawk_parser/tests/snapshots/tests__create_domain_ok.snap index e02cb0ad..a7bca643 100644 --- a/crates/squawk_parser/tests/snapshots/tests__create_domain_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__create_domain_ok.snap @@ -6,7 +6,7 @@ snapshot_kind: text SOURCE_FILE COMMENT "-- simple" WHITESPACE "\n" - CREATE_DOMAIN_STMT + CREATE_DOMAIN CREATE_KW "create" WHITESPACE " " DOMAIN_KW "domain" @@ -23,7 +23,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- full" WHITESPACE "\n" - CREATE_DOMAIN_STMT + CREATE_DOMAIN CREATE_KW "create" WHITESPACE " " DOMAIN_KW "domain" diff --git a/crates/squawk_parser/tests/snapshots/tests__create_function_err.snap b/crates/squawk_parser/tests/snapshots/tests__create_function_err.snap index 351eb2cc..54794614 100644 --- a/crates/squawk_parser/tests/snapshots/tests__create_function_err.snap +++ b/crates/squawk_parser/tests/snapshots/tests__create_function_err.snap @@ -6,7 +6,7 @@ snapshot_kind: text SOURCE_FILE COMMENT "-- regression partial definition" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" diff --git a/crates/squawk_parser/tests/snapshots/tests__create_function_ok.snap b/crates/squawk_parser/tests/snapshots/tests__create_function_ok.snap index 8c442f88..06c19cca 100644 --- a/crates/squawk_parser/tests/snapshots/tests__create_function_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__create_function_ok.snap @@ -6,7 +6,7 @@ snapshot_kind: text SOURCE_FILE COMMENT "-- create_func_with_in_out" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -71,7 +71,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- security_definer" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "CREATE" WHITESPACE " " FUNCTION_KW "FUNCTION" @@ -152,7 +152,7 @@ SOURCE_FILE WHITESPACE "\n" COMMENT "-- column type return" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -214,7 +214,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- setof return" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -264,7 +264,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- void return" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -307,7 +307,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- omitted return" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -336,7 +336,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- schema" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -377,7 +377,7 @@ SOURCE_FILE STRING "'sql'" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -428,7 +428,7 @@ SOURCE_FILE STRING "'sql'" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -474,7 +474,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- returns table" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -528,7 +528,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- transform" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -589,7 +589,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- transform with type with args" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -645,7 +645,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- window" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -685,7 +685,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- immutable, stable, volatile" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -723,7 +723,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -761,7 +761,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -801,7 +801,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- [ not ] leakproof" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -841,7 +841,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -881,7 +881,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -925,7 +925,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -971,7 +971,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1011,7 +1011,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1053,7 +1053,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1093,7 +1093,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1135,7 +1135,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1177,7 +1177,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- parallel" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1217,7 +1217,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1257,7 +1257,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1299,7 +1299,7 @@ SOURCE_FILE WHITESPACE "\n\n\n" COMMENT "-- cost" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1342,7 +1342,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- rows" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1385,7 +1385,7 @@ SOURCE_FILE WHITESPACE "\n\n\n" COMMENT "-- suport" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1433,7 +1433,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1478,7 +1478,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- set configuration_parameter" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1530,7 +1530,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1578,7 +1578,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1628,7 +1628,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- as def" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1665,7 +1665,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- as 'object_file', 'link_symbol'" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1706,7 +1706,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- return" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1752,7 +1752,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- begin atomic" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1808,7 +1808,7 @@ SOURCE_FILE END_KW "end" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1860,7 +1860,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- lots of ;" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -1923,7 +1923,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- all options" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2067,7 +2067,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- regression" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2105,7 +2105,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2154,7 +2154,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- argmode" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2195,7 +2195,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2236,7 +2236,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2279,7 +2279,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2320,7 +2320,7 @@ SOURCE_FILE SQL_KW "sql" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2365,7 +2365,7 @@ SOURCE_FILE WHITESPACE "\n\n\n" COMMENT "-- single arg" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2411,7 +2411,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- multi args" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2468,7 +2468,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- named and unnamed" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2521,7 +2521,7 @@ SOURCE_FILE WHITESPACE "\n" COMMENT "-- =" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2584,7 +2584,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- not a parser error but something to warn about" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2641,7 +2641,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- default" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2693,7 +2693,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- expr w/ default" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2751,7 +2751,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- expr w/ =" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2811,7 +2811,7 @@ SOURCE_FILE WHITESPACE "\n" COMMENT "-- mode name type" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2860,7 +2860,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- mode type" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2903,7 +2903,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- name mode type" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2952,7 +2952,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- name type" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" @@ -2998,7 +2998,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- type" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " FUNCTION_KW "function" diff --git a/crates/squawk_parser/tests/snapshots/tests__create_index_ok.snap b/crates/squawk_parser/tests/snapshots/tests__create_index_ok.snap index 689d5162..7e18cde9 100644 --- a/crates/squawk_parser/tests/snapshots/tests__create_index_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__create_index_ok.snap @@ -15,10 +15,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "on" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -50,12 +51,13 @@ SOURCE_FILE WHITESPACE " \n " ON_KW "on" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " \n " USING_KW "using" WHITESPACE " " @@ -78,10 +80,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "on" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -109,10 +112,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "on" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -136,10 +140,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "on" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -193,10 +198,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "on" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -233,10 +239,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "on" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -314,10 +321,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "on" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -354,15 +362,16 @@ SOURCE_FILE WHITESPACE " " ON_KW "on" WHITESPACE " " - PATH + RELATION_NAME PATH + PATH + PATH_SEGMENT + NAME_REF + IDENT "public" + DOT "." PATH_SEGMENT NAME_REF - IDENT "public" - DOT "." - PATH_SEGMENT - NAME_REF - IDENT "t" + IDENT "t" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -385,10 +394,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -409,10 +419,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -446,10 +457,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -480,10 +492,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -511,10 +524,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -539,10 +553,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -567,10 +582,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -604,10 +620,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "documents_table" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "documents_table" WHITESPACE " " USING_KW "USING" WHITESPACE " " @@ -646,10 +663,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -673,10 +691,11 @@ SOURCE_FILE WHITESPACE "\n " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "points" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "points" WHITESPACE " " USING_KW "USING" WHITESPACE " " @@ -711,10 +730,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "sales_table" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "sales_table" WHITESPACE " " INDEX_PARAMS L_PAREN "(" diff --git a/crates/squawk_parser/tests/snapshots/tests__create_materialized_view_ok.snap b/crates/squawk_parser/tests/snapshots/tests__create_materialized_view_ok.snap index f1624682..27c7d289 100644 --- a/crates/squawk_parser/tests/snapshots/tests__create_materialized_view_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__create_materialized_view_ok.snap @@ -162,10 +162,11 @@ SOURCE_FILE TABLE_STMT TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "u" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "u" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- values" diff --git a/crates/squawk_parser/tests/snapshots/tests__create_rule_ok.snap b/crates/squawk_parser/tests/snapshots/tests__create_rule_ok.snap index 1bce7cbf..7cfe8d30 100644 --- a/crates/squawk_parser/tests/snapshots/tests__create_rule_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__create_rule_ok.snap @@ -147,10 +147,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" SEMICOLON ";" WHITESPACE "\n " VALUES @@ -169,10 +170,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "update" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " SET_KW "set" WHITESPACE " " @@ -329,10 +331,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "mytable" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "mytable" WHITESPACE " " SET_KW "SET" WHITESPACE " " diff --git a/crates/squawk_parser/tests/snapshots/tests__create_table_as_ok.snap b/crates/squawk_parser/tests/snapshots/tests__create_table_as_ok.snap index b00c21cb..eb45b8ba 100644 --- a/crates/squawk_parser/tests/snapshots/tests__create_table_as_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__create_table_as_ok.snap @@ -96,10 +96,11 @@ SOURCE_FILE TABLE_STMT TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "u" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "u" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- values" diff --git a/crates/squawk_parser/tests/snapshots/tests__delete_ok.snap b/crates/squawk_parser/tests/snapshots/tests__delete_ok.snap index ddc52faa..a92e699d 100644 --- a/crates/squawk_parser/tests/snapshots/tests__delete_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__delete_ok.snap @@ -13,10 +13,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " WHERE_CLAUSE WHERE_KW "where" @@ -38,10 +39,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- only" @@ -51,12 +53,13 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- *" @@ -66,12 +69,13 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" - WHITESPACE " " - STAR "*" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" + WHITESPACE " " + STAR "*" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- alias" @@ -81,10 +85,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " AS_KW "as" WHITESPACE " " @@ -96,10 +101,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " IDENT "a" SEMICOLON ";" @@ -111,12 +117,13 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " AS_KW "as" WHITESPACE " " @@ -156,10 +163,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " \n" USING_CLAUSE USING_KW "using" @@ -185,10 +193,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n" USING_CLAUSE USING_KW "using" @@ -237,10 +246,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "user_sessions" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "user_sessions" WHITESPACE " " IDENT "us" WHITESPACE "\n" @@ -309,10 +319,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " WHERE_CLAUSE WHERE_KW "where" @@ -338,10 +349,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "employees" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "employees" WHITESPACE " " IDENT "e" WHITESPACE "\n" @@ -423,10 +435,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "invoices" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "invoices" WHITESPACE " \n" WHERE_KW "where" WHITESPACE " " @@ -444,10 +457,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " \n" RETURNING_KW "returning" WHITESPACE " " @@ -500,10 +514,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " AS_KW "as" WHITESPACE " " @@ -571,10 +586,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " AS_KW "as" WHITESPACE " " @@ -669,10 +685,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " USING_CLAUSE USING_KW "using" @@ -688,10 +705,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "FROM" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " USING_CLAUSE USING_KW "USING" @@ -737,10 +755,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "FROM" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE "\n " WHERE_CLAUSE WHERE_KW "WHERE" @@ -787,10 +806,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "FROM" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " WHERE_CLAUSE WHERE_KW "WHERE" @@ -810,10 +830,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "FROM" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" SEMICOLON ";" WHITESPACE "\n\n" DELETE_STMT @@ -821,10 +842,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "FROM" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "tasks" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "tasks" WHITESPACE " " WHERE_CLAUSE WHERE_KW "WHERE" @@ -848,10 +870,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "FROM" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "tasks" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "tasks" WHITESPACE " " WHERE_KW "WHERE" WHITESPACE " " @@ -944,10 +967,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "FROM" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "user_logs" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "user_logs" WHITESPACE " " AS_KW "AS" WHITESPACE " " diff --git a/crates/squawk_parser/tests/snapshots/tests__drop_aggregate_ok.snap b/crates/squawk_parser/tests/snapshots/tests__drop_aggregate_ok.snap index d8dbd623..884b5247 100644 --- a/crates/squawk_parser/tests/snapshots/tests__drop_aggregate_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__drop_aggregate_ok.snap @@ -11,7 +11,7 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - CALL_EXPR + AGGREGATE PATH PATH_SEGMENT NAME_REF @@ -34,7 +34,7 @@ SOURCE_FILE WHITESPACE " " EXISTS_KW "exists" WHITESPACE " \n " - CALL_EXPR + AGGREGATE PATH PATH_SEGMENT NAME_REF @@ -45,7 +45,7 @@ SOURCE_FILE R_PAREN ")" COMMA "," WHITESPACE " \n " - CALL_EXPR + AGGREGATE PATH PATH PATH_SEGMENT @@ -61,7 +61,7 @@ SOURCE_FILE R_PAREN ")" COMMA "," WHITESPACE " \n " - CALL_EXPR + AGGREGATE PATH PATH PATH_SEGMENT @@ -106,7 +106,7 @@ SOURCE_FILE R_PAREN ")" COMMA "," WHITESPACE " \n " - CALL_EXPR + AGGREGATE PATH PATH_SEGMENT NAME_REF @@ -126,7 +126,7 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - CALL_EXPR + AGGREGATE PATH PATH_SEGMENT NAME_REF @@ -195,7 +195,7 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - CALL_EXPR + AGGREGATE PATH PATH PATH_SEGMENT diff --git a/crates/squawk_parser/tests/snapshots/tests__drop_database_ok.snap b/crates/squawk_parser/tests/snapshots/tests__drop_database_ok.snap index fe762dc1..31a5127d 100644 --- a/crates/squawk_parser/tests/snapshots/tests__drop_database_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__drop_database_ok.snap @@ -6,7 +6,7 @@ snapshot_kind: text SOURCE_FILE COMMENT "-- drop_database" WHITESPACE "\n" - DROP_DATABASE_STMT + DROP_DATABASE DROP_KW "drop" WHITESPACE " " DATABASE_KW "database" @@ -15,7 +15,7 @@ SOURCE_FILE IDENT "d" SEMICOLON ";" WHITESPACE "\n\n" - DROP_DATABASE_STMT + DROP_DATABASE DROP_KW "drop" WHITESPACE " " DATABASE_KW "database" @@ -29,7 +29,7 @@ SOURCE_FILE R_PAREN ")" SEMICOLON ";" WHITESPACE "\n" - DROP_DATABASE_STMT + DROP_DATABASE DROP_KW "drop" WHITESPACE " " DATABASE_KW "database" @@ -49,7 +49,7 @@ SOURCE_FILE R_PAREN ")" SEMICOLON ";" WHITESPACE "\n\n" - DROP_DATABASE_STMT + DROP_DATABASE DROP_KW "drop" WHITESPACE " " DATABASE_KW "database" @@ -58,7 +58,7 @@ SOURCE_FILE IDENT "\"table_name\"" SEMICOLON ";" WHITESPACE "\n\n" - DROP_DATABASE_STMT + DROP_DATABASE DROP_KW "drop" WHITESPACE " " DATABASE_KW "database" @@ -72,7 +72,7 @@ SOURCE_FILE IDENT "\"table_name\"" SEMICOLON ";" WHITESPACE "\n\n" - DROP_DATABASE_STMT + DROP_DATABASE DROP_KW "drop" WHITESPACE " " DATABASE_KW "database" diff --git a/crates/squawk_parser/tests/snapshots/tests__drop_index_ok.snap b/crates/squawk_parser/tests/snapshots/tests__drop_index_ok.snap index bdca5e86..9b3b083d 100644 --- a/crates/squawk_parser/tests/snapshots/tests__drop_index_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__drop_index_ok.snap @@ -6,7 +6,7 @@ snapshot_kind: text SOURCE_FILE COMMENT "-- drop_index" WHITESPACE "\n" - DROP_INDEX_STMT + DROP_INDEX DROP_KW "drop" WHITESPACE " " INDEX_KW "index" @@ -17,7 +17,7 @@ SOURCE_FILE IDENT "i" SEMICOLON ";" WHITESPACE "\n\n" - DROP_INDEX_STMT + DROP_INDEX DROP_KW "drop" WHITESPACE " " INDEX_KW "index" @@ -33,7 +33,7 @@ SOURCE_FILE IDENT "i" SEMICOLON ";" WHITESPACE "\n\n" - DROP_INDEX_STMT + DROP_INDEX DROP_KW "drop" WHITESPACE " " INDEX_KW "index" @@ -65,7 +65,7 @@ SOURCE_FILE CASCADE_KW "cascade" SEMICOLON ";" WHITESPACE "\n\n" - DROP_INDEX_STMT + DROP_INDEX DROP_KW "drop" WHITESPACE " " INDEX_KW "index" @@ -83,7 +83,7 @@ SOURCE_FILE RESTRICT_KW "restrict" SEMICOLON ";" WHITESPACE "\n\n" - DROP_INDEX_STMT + DROP_INDEX DROP_KW "drop" WHITESPACE " " INDEX_KW "index" @@ -99,7 +99,7 @@ SOURCE_FILE IDENT "\"field_name_idx\"" SEMICOLON ";" WHITESPACE "\n\n" - DROP_INDEX_STMT + DROP_INDEX DROP_KW "drop" WHITESPACE " " INDEX_KW "index" diff --git a/crates/squawk_parser/tests/snapshots/tests__insert_ok.snap b/crates/squawk_parser/tests/snapshots/tests__insert_ok.snap index 8dd064b8..bf7f8863 100644 --- a/crates/squawk_parser/tests/snapshots/tests__insert_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__insert_ok.snap @@ -831,10 +831,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "employees" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "employees" WHITESPACE " " SET_KW "SET" WHITESPACE " " diff --git a/crates/squawk_parser/tests/snapshots/tests__lock_ok.snap b/crates/squawk_parser/tests/snapshots/tests__lock_ok.snap index 3b8bd999..be21098c 100644 --- a/crates/squawk_parser/tests/snapshots/tests__lock_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__lock_ok.snap @@ -10,10 +10,11 @@ SOURCE_FILE LOCK_KW "lock" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- table_names" @@ -24,26 +25,29 @@ SOURCE_FILE TABLE_KW "table" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" COMMA "," WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "b" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "b" COMMA "," WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "c" - WHITESPACE " " - STAR "*" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "c" + WHITESPACE " " + STAR "*" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- lock_mode" @@ -52,10 +56,11 @@ SOURCE_FILE LOCK_KW "lock" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " IN_KW "in" WHITESPACE " " @@ -70,10 +75,11 @@ SOURCE_FILE LOCK_KW "lock" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " IN_KW "in" WHITESPACE " " @@ -88,10 +94,11 @@ SOURCE_FILE LOCK_KW "lock" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " IN_KW "in" WHITESPACE " " @@ -106,10 +113,11 @@ SOURCE_FILE LOCK_KW "lock" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " IN_KW "in" WHITESPACE " " @@ -126,10 +134,11 @@ SOURCE_FILE LOCK_KW "lock" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " IN_KW "in" WHITESPACE " " @@ -142,10 +151,11 @@ SOURCE_FILE LOCK_KW "lock" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " IN_KW "in" WHITESPACE " " @@ -162,10 +172,11 @@ SOURCE_FILE LOCK_KW "lock" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " IN_KW "in" WHITESPACE " " @@ -178,10 +189,11 @@ SOURCE_FILE LOCK_KW "lock" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " IN_KW "in" WHITESPACE " " @@ -200,26 +212,29 @@ SOURCE_FILE TABLE_KW "table" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" COMMA "," WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" - WHITESPACE " " - STAR "*" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" + WHITESPACE " " + STAR "*" COMMA "," WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "c" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "c" WHITESPACE " " IN_KW "in" WHITESPACE " " diff --git a/crates/squawk_parser/tests/snapshots/tests__merge_ok.snap b/crates/squawk_parser/tests/snapshots/tests__merge_ok.snap index abff57b6..f122bb4d 100644 --- a/crates/squawk_parser/tests/snapshots/tests__merge_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__merge_ok.snap @@ -11,10 +11,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -59,10 +60,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "foo" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" WHITESPACE " " ALIAS AS_KW "as" @@ -119,10 +121,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -169,10 +172,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "foo" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" WHITESPACE " " ALIAS NAME @@ -225,12 +229,13 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" - WHITESPACE " " - STAR "*" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" + WHITESPACE " " + STAR "*" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -275,12 +280,13 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -325,12 +331,13 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -388,12 +395,13 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -488,12 +496,13 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -557,10 +566,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" diff --git a/crates/squawk_parser/tests/snapshots/tests__merge_pg17_ok.snap b/crates/squawk_parser/tests/snapshots/tests__merge_pg17_ok.snap index 1bbeaffb..4d8f50c9 100644 --- a/crates/squawk_parser/tests/snapshots/tests__merge_pg17_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__merge_pg17_ok.snap @@ -12,10 +12,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -88,10 +89,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -183,10 +185,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -263,10 +266,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -372,10 +376,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -424,10 +429,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -499,10 +505,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -589,10 +596,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -759,10 +767,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -849,10 +858,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "u" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "u" WHITESPACE "\n " USING_CLAUSE USING_KW "using" @@ -897,10 +907,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "INTO" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "customer_account" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "customer_account" WHITESPACE " " ALIAS NAME @@ -1009,10 +1020,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "INTO" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "customer_account" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "customer_account" WHITESPACE " " ALIAS NAME @@ -1143,10 +1155,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "INTO" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "wines" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "wines" WHITESPACE " " ALIAS NAME @@ -1314,10 +1327,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "INTO" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "wines" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "wines" WHITESPACE " " ALIAS NAME diff --git a/crates/squawk_parser/tests/snapshots/tests__misc_ok.snap b/crates/squawk_parser/tests/snapshots/tests__misc_ok.snap index d57e4060..8dd7af84 100644 --- a/crates/squawk_parser/tests/snapshots/tests__misc_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__misc_ok.snap @@ -221,10 +221,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "movies" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "movies" WHITESPACE "\n" SET_KW "SET" WHITESPACE " " @@ -751,7 +752,7 @@ SOURCE_FILE WHITESPACE "\n\n\n" COMMENT "-- https://www.depesz.com/2024/11/15/grouping-data-into-array-of-sums-fun-with-custom-aggregates/" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "CREATE" WHITESPACE " " FUNCTION_KW "FUNCTION" @@ -860,7 +861,7 @@ SOURCE_FILE R_PAREN ")" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_AGGREGATE_STMT + CREATE_AGGREGATE CREATE_KW "CREATE" WHITESPACE " " AGGREGATE_KW "aggregate" @@ -1110,7 +1111,7 @@ SOURCE_FILE INT_NUMBER "3" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "CREATE" WHITESPACE " " FUNCTION_KW "FUNCTION" @@ -1314,19 +1315,21 @@ SOURCE_FILE TABLE_STMT TABLE_KW "Table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "\"partman_test.time_taptest_table_p20241124\"" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "\"partman_test.time_taptest_table_p20241124\"" SEMICOLON ";" WHITESPACE "\n\n" TABLE_STMT TABLE_KW "Table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "\"partman_test.time_taptest_table_default\"" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "\"partman_test.time_taptest_table_default\"" SEMICOLON ";" WHITESPACE "\n\n" CREATE_TABLE @@ -1427,15 +1430,16 @@ SOURCE_FILE WHITESPACE " " FROM_KW "FROM" WHITESPACE " " - PATH + RELATION_NAME PATH + PATH + PATH_SEGMENT + NAME_REF + IDENT "partman_test" + DOT "." PATH_SEGMENT NAME_REF - IDENT "partman_test" - DOT "." - PATH_SEGMENT - NAME_REF - IDENT "time_taptest_table_default" + IDENT "time_taptest_table_default" WHITESPACE " " RETURNING_KW "RETURNING" WHITESPACE " " @@ -1560,10 +1564,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "FROM" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "clean_default_temp" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "clean_default_temp" WHITESPACE " " RETURNING_KW "RETURNING" WHITESPACE " " @@ -1958,10 +1963,11 @@ SOURCE_FILE WHITESPACE " " TABLE_KW "TABLE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "tng" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "tng" WHITESPACE "\n " ADD_COLUMN ADD_KW "ADD" @@ -1983,10 +1989,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "tng" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "tng" WHITESPACE "\n " SET_KW "SET" WHITESPACE " " @@ -2097,7 +2104,7 @@ SOURCE_FILE INT_NUMBER "5" SEMICOLON ";" WHITESPACE "\n\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "CREATE" WHITESPACE " " OR_REPLACE @@ -2296,10 +2303,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "on" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "events" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "events" WHITESPACE " " USING_KW "using" WHITESPACE " " @@ -2561,10 +2569,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "on" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "events_json" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "events_json" WHITESPACE " " USING_KW "using" WHITESPACE " " @@ -2672,10 +2681,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "on" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "events" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "events" WHITESPACE " " USING_KW "using" WHITESPACE " " @@ -2753,7 +2763,7 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "/* define a function that wraps a COPY TO command to export data */" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " OR_REPLACE @@ -2883,7 +2893,7 @@ SOURCE_FILE WHITESPACE "\n\n\n" COMMENT "/* define function that wraps a COPY FROM command to import data */" WHITESPACE "\n" - CREATE_FUNCTION_STMT + CREATE_FUNCTION CREATE_KW "create" WHITESPACE " " OR_REPLACE @@ -3665,10 +3675,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "hourly_stats" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "hourly_stats" INDEX_PARAMS L_PAREN "(" NAME_REF @@ -5465,10 +5476,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "events" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "events" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -5499,10 +5511,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "event_logs" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "event_logs" WHITESPACE "\n" USING_KW "USING" WHITESPACE " " @@ -5750,10 +5763,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "recent_product_sales" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "recent_product_sales" WHITESPACE " " INDEX_PARAMS L_PAREN "(" @@ -5787,10 +5801,11 @@ SOURCE_FILE WHITESPACE " " ON_KW "ON" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "recent_product_sales" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "recent_product_sales" INDEX_PARAMS L_PAREN "(" NAME_REF @@ -5798,7 +5813,7 @@ SOURCE_FILE R_PAREN ")" SEMICOLON ";" WHITESPACE "\n\n" - DROP_INDEX_STMT + DROP_INDEX DROP_KW "DROP" WHITESPACE " " INDEX_KW "INDEX" diff --git a/crates/squawk_parser/tests/snapshots/tests__prepare_ok.snap b/crates/squawk_parser/tests/snapshots/tests__prepare_ok.snap index b907546d..75a8d4a1 100644 --- a/crates/squawk_parser/tests/snapshots/tests__prepare_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__prepare_ok.snap @@ -222,10 +222,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "update" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "foo" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" WHITESPACE " " SET_KW "set" WHITESPACE " " @@ -265,10 +266,11 @@ SOURCE_FILE WHITESPACE " " FROM_KW "from" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "foo" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" WHITESPACE " " WHERE_CLAUSE WHERE_KW "where" @@ -298,10 +300,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t1" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t1" WHITESPACE "\n " USING_CLAUSE USING_KW "using" diff --git a/crates/squawk_parser/tests/snapshots/tests__schemas_ok.snap b/crates/squawk_parser/tests/snapshots/tests__schemas_ok.snap index e78fb13f..9d627f4c 100644 --- a/crates/squawk_parser/tests/snapshots/tests__schemas_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__schemas_ok.snap @@ -199,34 +199,36 @@ SOURCE_FILE TABLE_STMT TABLE_KW "table" WHITESPACE " " - PATH + RELATION_NAME PATH + PATH + PATH_SEGMENT + NAME_REF + SCHEMA_KW "schema" + DOT "." PATH_SEGMENT NAME_REF - SCHEMA_KW "schema" - DOT "." - PATH_SEGMENT - NAME_REF - TABLE_KW "table" + TABLE_KW "table" SEMICOLON ";" WHITESPACE "\n" TABLE_STMT TABLE_KW "table" WHITESPACE " " - PATH + RELATION_NAME PATH PATH + PATH + PATH_SEGMENT + NAME_REF + DATABASE_KW "database" + DOT "." PATH_SEGMENT NAME_REF - DATABASE_KW "database" + SCHEMA_KW "schema" DOT "." PATH_SEGMENT NAME_REF - SCHEMA_KW "schema" - DOT "." - PATH_SEGMENT - NAME_REF - TABLE_KW "table" + TABLE_KW "table" SEMICOLON ";" WHITESPACE "\n\n" DROP_SCHEMA_STMT diff --git a/crates/squawk_parser/tests/snapshots/tests__security_label_ok.snap b/crates/squawk_parser/tests/snapshots/tests__security_label_ok.snap index f9ed330a..9bc130af 100644 --- a/crates/squawk_parser/tests/snapshots/tests__security_label_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__security_label_ok.snap @@ -90,19 +90,20 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH + AGGREGATE PATH + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" + DOT "." PATH_SEGMENT NAME_REF - IDENT "foo" - DOT "." - PATH_SEGMENT - NAME - IDENT "bar" - PARAM_LIST - L_PAREN "(" - STAR "*" - R_PAREN ")" + IDENT "bar" + PARAM_LIST + L_PAREN "(" + STAR "*" + R_PAREN ")" WHITESPACE " " IS_KW "is" WHITESPACE " " @@ -121,48 +122,49 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH + AGGREGATE PATH + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" + DOT "." PATH_SEGMENT NAME_REF + IDENT "bar" + PARAM_LIST + L_PAREN "(" + WHITESPACE "\n " + PARAM + PARAM_IN + IN_KW "in" + WHITESPACE " " + NAME IDENT "foo" - DOT "." - PATH_SEGMENT - NAME - IDENT "bar" - PARAM_LIST - L_PAREN "(" - WHITESPACE "\n " - PARAM - PARAM_IN - IN_KW "in" - WHITESPACE " " - NAME - IDENT "foo" - WHITESPACE " " - PATH_TYPE - PATH - PATH_SEGMENT - NAME_REF - INTEGER_KW "integer" - COMMA "," - WHITESPACE "\n " - PARAM - NAME - IDENT "bar" - WHITESPACE " " - PATH_TYPE - PATH - PATH_SEGMENT - NAME_REF - INTEGER_KW "integer" - COMMA "," - WHITESPACE "\n " - PARAM - PATH_TYPE - TEXT_KW "text" - WHITESPACE "\n" - R_PAREN ")" + WHITESPACE " " + PATH_TYPE + PATH + PATH_SEGMENT + NAME_REF + INTEGER_KW "integer" + COMMA "," + WHITESPACE "\n " + PARAM + NAME + IDENT "bar" + WHITESPACE " " + PATH_TYPE + PATH + PATH_SEGMENT + NAME_REF + INTEGER_KW "integer" + COMMA "," + WHITESPACE "\n " + PARAM + PATH_TYPE + TEXT_KW "text" + WHITESPACE "\n" + R_PAREN ")" WHITESPACE " " IS_KW "is" WHITESPACE " " @@ -181,70 +183,71 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH + AGGREGATE PATH + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" + DOT "." PATH_SEGMENT NAME_REF - IDENT "foo" - DOT "." - PATH_SEGMENT - NAME - IDENT "bar" - PARAM_LIST - L_PAREN "(" - WHITESPACE "\n " - PARAM - PATH_TYPE - PATH - PATH_SEGMENT - NAME_REF - INTEGER_KW "integer" - COMMA "," - WHITESPACE "\n " - PARAM - PATH_TYPE - TEXT_KW "text" - COMMA "," - WHITESPACE "\n " - PARAM - PATH_TYPE - PATH - PATH_SEGMENT - NAME_REF - NUMERIC_KW "numeric" - WHITESPACE "\n " - ORDER_KW "order" - WHITESPACE " " - BY_KW "by" - WHITESPACE "\n " - PARAM - PARAM_IN - IN_KW "in" - WHITESPACE " " - NAME - IDENT "a" - WHITESPACE " " - TIME_TYPE - NAME_REF - TIMESTAMP_KW "timestamp" - COMMA "," - WHITESPACE "\n " - PARAM - NAME - IDENT "b" + IDENT "bar" + PARAM_LIST + L_PAREN "(" + WHITESPACE "\n " + PARAM + PATH_TYPE + PATH + PATH_SEGMENT + NAME_REF + INTEGER_KW "integer" + COMMA "," + WHITESPACE "\n " + PARAM + PATH_TYPE + TEXT_KW "text" + COMMA "," + WHITESPACE "\n " + PARAM + PATH_TYPE + PATH + PATH_SEGMENT + NAME_REF + NUMERIC_KW "numeric" + WHITESPACE "\n " + ORDER_KW "order" WHITESPACE " " - PATH_TYPE - PATH - PATH_SEGMENT - NAME_REF - NUMERIC_KW "numeric" - COMMA "," - WHITESPACE "\n " - PARAM - PATH_TYPE - TEXT_KW "text" - WHITESPACE "\n" - R_PAREN ")" + BY_KW "by" + WHITESPACE "\n " + PARAM + PARAM_IN + IN_KW "in" + WHITESPACE " " + NAME + IDENT "a" + WHITESPACE " " + TIME_TYPE + NAME_REF + TIMESTAMP_KW "timestamp" + COMMA "," + WHITESPACE "\n " + PARAM + NAME + IDENT "b" + WHITESPACE " " + PATH_TYPE + PATH + PATH_SEGMENT + NAME_REF + NUMERIC_KW "numeric" + COMMA "," + WHITESPACE "\n " + PARAM + PATH_TYPE + TEXT_KW "text" + WHITESPACE "\n" + R_PAREN ")" WHITESPACE " " IS_KW "is" WHITESPACE " " @@ -261,50 +264,51 @@ SOURCE_FILE WHITESPACE " " AGGREGATE_KW "aggregate" WHITESPACE " " - PATH + AGGREGATE PATH + PATH + PATH_SEGMENT + NAME_REF + IDENT "foo" + DOT "." PATH_SEGMENT NAME_REF - IDENT "foo" - DOT "." - PATH_SEGMENT - NAME - IDENT "bar" - PARAM_LIST - L_PAREN "(" - WHITESPACE "\n " - ORDER_KW "order" - WHITESPACE " " - BY_KW "by" - WHITESPACE "\n " - PARAM - PARAM_IN - IN_KW "in" - WHITESPACE " " - NAME - IDENT "a" - WHITESPACE " " - TIME_TYPE - NAME_REF - TIMESTAMP_KW "timestamp" - COMMA "," - WHITESPACE "\n " - PARAM - NAME - IDENT "b" + IDENT "bar" + PARAM_LIST + L_PAREN "(" + WHITESPACE "\n " + ORDER_KW "order" WHITESPACE " " - PATH_TYPE - PATH - PATH_SEGMENT - NAME_REF - NUMERIC_KW "numeric" - COMMA "," - WHITESPACE "\n " - PARAM - PATH_TYPE - TEXT_KW "text" - WHITESPACE "\n" - R_PAREN ")" + BY_KW "by" + WHITESPACE "\n " + PARAM + PARAM_IN + IN_KW "in" + WHITESPACE " " + NAME + IDENT "a" + WHITESPACE " " + TIME_TYPE + NAME_REF + TIMESTAMP_KW "timestamp" + COMMA "," + WHITESPACE "\n " + PARAM + NAME + IDENT "b" + WHITESPACE " " + PATH_TYPE + PATH + PATH_SEGMENT + NAME_REF + NUMERIC_KW "numeric" + COMMA "," + WHITESPACE "\n " + PARAM + PATH_TYPE + TEXT_KW "text" + WHITESPACE "\n" + R_PAREN ")" WHITESPACE " " IS_KW "is" WHITESPACE " " diff --git a/crates/squawk_parser/tests/snapshots/tests__select_cte_ok.snap b/crates/squawk_parser/tests/snapshots/tests__select_cte_ok.snap index 4303d276..3399fd47 100644 --- a/crates/squawk_parser/tests/snapshots/tests__select_cte_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__select_cte_ok.snap @@ -23,10 +23,11 @@ SOURCE_FILE WHITESPACE " " INTO_KW "into" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n " USING_CLAUSE USING_KW "using" diff --git a/crates/squawk_parser/tests/snapshots/tests__select_ok.snap b/crates/squawk_parser/tests/snapshots/tests__select_ok.snap index c4040d4f..6fd8fcf8 100644 --- a/crates/squawk_parser/tests/snapshots/tests__select_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__select_ok.snap @@ -4942,10 +4942,11 @@ SOURCE_FILE TABLE_STMT TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- only" @@ -4953,12 +4954,13 @@ SOURCE_FILE TABLE_STMT TABLE_KW "table" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- star" @@ -4966,12 +4968,13 @@ SOURCE_FILE TABLE_STMT TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" - WHITESPACE " " - STAR "*" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" + WHITESPACE " " + STAR "*" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- nested" @@ -4987,10 +4990,11 @@ SOURCE_FILE TABLE_STMT TABLE_KW "table" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" R_PAREN ")" SEMICOLON ";" WHITESPACE "\n\n" diff --git a/crates/squawk_parser/tests/snapshots/tests__transaction_ok.snap b/crates/squawk_parser/tests/snapshots/tests__transaction_ok.snap index 2ff1fecd..6a433e7b 100644 --- a/crates/squawk_parser/tests/snapshots/tests__transaction_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__transaction_ok.snap @@ -267,7 +267,7 @@ SOURCE_FILE IDENT "foo" SEMICOLON ";" WHITESPACE "\n\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" WHITESPACE " " TO_KW "to" @@ -278,7 +278,7 @@ SOURCE_FILE IDENT "foo" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" WHITESPACE " " WORK_KW "work" @@ -291,7 +291,7 @@ SOURCE_FILE IDENT "foo" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" WHITESPACE " " TRANSACTION_KW "transaction" @@ -304,7 +304,7 @@ SOURCE_FILE IDENT "foo" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" WHITESPACE " " TO_KW "to" @@ -313,7 +313,7 @@ SOURCE_FILE IDENT "foo" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" WHITESPACE " " WORK_KW "work" @@ -324,7 +324,7 @@ SOURCE_FILE IDENT "foo" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" WHITESPACE " " TRANSACTION_KW "transaction" @@ -369,23 +369,23 @@ SOURCE_FILE CHAIN_KW "chain" SEMICOLON ";" WHITESPACE "\n\n" - ROLLBACK_STMT + ROLLBACK ABORT_KW "abort" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ABORT_KW "abort" WHITESPACE " " WORK_KW "work" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ABORT_KW "abort" WHITESPACE " " TRANSACTION_KW "transaction" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ABORT_KW "abort" WHITESPACE " " AND_KW "and" @@ -393,7 +393,7 @@ SOURCE_FILE CHAIN_KW "chain" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ABORT_KW "abort" WHITESPACE " " AND_KW "and" @@ -403,23 +403,23 @@ SOURCE_FILE CHAIN_KW "chain" SEMICOLON ";" WHITESPACE "\n\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" WHITESPACE " " WORK_KW "work" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" WHITESPACE " " TRANSACTION_KW "transaction" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" WHITESPACE " " AND_KW "and" @@ -427,7 +427,7 @@ SOURCE_FILE CHAIN_KW "chain" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" WHITESPACE " " AND_KW "and" @@ -437,7 +437,7 @@ SOURCE_FILE CHAIN_KW "chain" SEMICOLON ";" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "rollback" WHITESPACE " " PREPARED_KW "prepared" diff --git a/crates/squawk_parser/tests/snapshots/tests__truncate_ok.snap b/crates/squawk_parser/tests/snapshots/tests__truncate_ok.snap index 4c4730c0..cfbed6c7 100644 --- a/crates/squawk_parser/tests/snapshots/tests__truncate_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__truncate_ok.snap @@ -6,18 +6,19 @@ snapshot_kind: text SOURCE_FILE COMMENT "-- pg_grammar" WHITESPACE "\n" - TRUNCATE_STMT + TRUNCATE TRUNCATE_KW "truncate" WHITESPACE " " TABLE_KW "table" WHITESPACE " " TABLE_LIST - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE "\n" RESTART_KW "restart" WHITESPACE " " @@ -28,66 +29,72 @@ SOURCE_FILE WHITESPACE "\n\n" COMMENT "-- multiple_tables" WHITESPACE "\n" - TRUNCATE_STMT + TRUNCATE TRUNCATE_KW "TRUNCATE" WHITESPACE " " TABLE_LIST - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" COMMA "," WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "b" - WHITESPACE " " - STAR "*" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "b" + WHITESPACE " " + STAR "*" COMMA "," WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "c" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "c" SEMICOLON ";" WHITESPACE "\n\n" COMMENT "-- rest" WHITESPACE "\n" - TRUNCATE_STMT + TRUNCATE TRUNCATE_KW "truncate" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" SEMICOLON ";" WHITESPACE "\n" - TRUNCATE_STMT + TRUNCATE TRUNCATE_KW "truncate" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" WHITESPACE " " CONTINUE_KW "continue" WHITESPACE " " IDENTITY_KW "identity" SEMICOLON ";" WHITESPACE "\n" - TRUNCATE_STMT + TRUNCATE TRUNCATE_KW "truncate" WHITESPACE " " TABLE_LIST - PATH - PATH_SEGMENT - NAME_REF - IDENT "a" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "a" WHITESPACE " " CONTINUE_KW "continue" WHITESPACE " " diff --git a/crates/squawk_parser/tests/snapshots/tests__update_ok.snap b/crates/squawk_parser/tests/snapshots/tests__update_ok.snap index 1bbb08dc..2baaa5b2 100644 --- a/crates/squawk_parser/tests/snapshots/tests__update_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__update_ok.snap @@ -11,10 +11,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "update" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " SET_KW "set" WHITESPACE " " @@ -44,10 +45,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "products" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "products" WHITESPACE " " SET_KW "SET" WHITESPACE " " @@ -71,10 +73,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "update" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "mytable" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "mytable" WHITESPACE " " SET_KW "set" WHITESPACE " " @@ -122,10 +125,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "update" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " SET_KW "set" WHITESPACE " " @@ -175,10 +179,11 @@ SOURCE_FILE WHITESPACE "\n" UPDATE_KW "update" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t2" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "t2" WHITESPACE " " SET_KW "set" WHITESPACE " \n " @@ -223,12 +228,13 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "update" WHITESPACE " " - ONLY_KW "only" - WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "t" + RELATION_NAME + ONLY_KW "only" + WHITESPACE " " + PATH + PATH_SEGMENT + NAME_REF + IDENT "t" WHITESPACE " " ALIAS AS_KW "as" @@ -359,10 +365,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " SET_KW "SET" WHITESPACE " " @@ -390,10 +397,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "weather" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "weather" WHITESPACE " " SET_KW "SET" WHITESPACE " " @@ -458,10 +466,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "weather" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "weather" WHITESPACE " " SET_KW "SET" WHITESPACE " " @@ -539,10 +548,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "weather" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "weather" WHITESPACE " " SET_KW "SET" WHITESPACE " " @@ -609,10 +619,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "employees" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "employees" WHITESPACE " " SET_KW "SET" WHITESPACE " " @@ -676,10 +687,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "employees" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "employees" WHITESPACE " " SET_KW "SET" WHITESPACE " " @@ -740,10 +752,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "accounts" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "accounts" WHITESPACE " " SET_KW "SET" WHITESPACE " " @@ -804,10 +817,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "accounts" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "accounts" WHITESPACE " " SET_KW "SET" WHITESPACE " " @@ -858,10 +872,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "summary" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "summary" WHITESPACE " " ALIAS NAME @@ -1008,7 +1023,7 @@ SOURCE_FILE WHITESPACE "\n" COMMENT "-- so now we issue these commands:" WHITESPACE "\n" - ROLLBACK_STMT + ROLLBACK ROLLBACK_KW "ROLLBACK" WHITESPACE " " TO_KW "TO" @@ -1020,10 +1035,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "wines" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "wines" WHITESPACE " " SET_KW "SET" WHITESPACE " " @@ -1063,10 +1079,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "films" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "films" WHITESPACE " " SET_KW "SET" WHITESPACE " " @@ -1183,10 +1200,11 @@ SOURCE_FILE WHITESPACE "\n" UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "work_item" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "work_item" WHITESPACE " " SET_KW "SET" WHITESPACE " " diff --git a/crates/squawk_parser/tests/snapshots/tests__values_ok.snap b/crates/squawk_parser/tests/snapshots/tests__values_ok.snap index c721a331..209046ca 100644 --- a/crates/squawk_parser/tests/snapshots/tests__values_ok.snap +++ b/crates/squawk_parser/tests/snapshots/tests__values_ok.snap @@ -284,10 +284,11 @@ SOURCE_FILE UPDATE_STMT UPDATE_KW "UPDATE" WHITESPACE " " - PATH - PATH_SEGMENT - NAME_REF - IDENT "employees" + RELATION_NAME + PATH + PATH_SEGMENT + NAME_REF + IDENT "employees" WHITESPACE " " SET_KW "SET" WHITESPACE " " diff --git a/crates/squawk_parser/tests/tests.rs b/crates/squawk_parser/tests/tests.rs index 49c21b26..91857103 100644 --- a/crates/squawk_parser/tests/tests.rs +++ b/crates/squawk_parser/tests/tests.rs @@ -2,10 +2,10 @@ use camino::Utf8Path; use dir_test::{dir_test, Fixture}; use insta::{assert_snapshot, with_settings}; +use squawk_parser::{parse, LexedStr}; +use std::fmt::Write; use std::fs::remove_file; -mod utils; - #[dir_test( dir: "$CARGO_MANIFEST_DIR/tests/data/ok", glob: "*.sql", @@ -19,7 +19,7 @@ fn parser_ok(fixture: Fixture<&str>) { .and_then(|x| x.strip_suffix(".sql")) .unwrap(); - let (parsed, has_errors) = utils::parse_text(content); + let (parsed, has_errors) = parse_text(content); with_settings!({ omit_expression => true, @@ -60,7 +60,7 @@ fn parser_err(fixture: Fixture<&str>) { .and_then(|x| x.strip_suffix(".sql")) .unwrap(); - let (parsed, has_errors) = utils::parse_text(content); + let (parsed, has_errors) = parse_text(content); with_settings!({ omit_expression => true, @@ -91,7 +91,7 @@ fn regression_suite(fixture: Fixture<&str>) { .and_then(|x| x.strip_suffix(".sql")) .unwrap(); - let (parsed, has_errors) = utils::parse_text(content); + let (parsed, has_errors) = parse_text(content); if has_errors { with_settings!({ @@ -111,3 +111,61 @@ fn regression_suite(fixture: Fixture<&str>) { let _ = remove_file(new_snapshot_path); } } + +fn parse_text(text: &str) -> (String, bool) { + let lexed = LexedStr::new(text); + let input = lexed.to_input(); + let output = parse(&input); + + let mut buf = String::new(); + let mut errors = Vec::new(); + let mut indent = String::new(); + let mut depth = 0; + let mut len = 0; + lexed.intersperse_trivia(&output, &mut |step| match step { + squawk_parser::StrStep::Token { kind, text } => { + assert!(depth > 0); + len += text.len(); + writeln!(buf, "{indent}{kind:?} {text:?}").unwrap(); + } + squawk_parser::StrStep::Enter { kind } => { + assert!(depth > 0 || len == 0); + depth += 1; + writeln!(buf, "{indent}{kind:?}").unwrap(); + indent.push_str(" "); + } + squawk_parser::StrStep::Exit => { + assert!(depth > 0); + depth -= 1; + indent.pop(); + indent.pop(); + } + squawk_parser::StrStep::Error { msg, pos } => { + assert!(depth > 0); + let err = "ERROR"; + errors.push(format!("{err}@{pos}: {msg}\n")); + } + }); + assert_eq!( + len, + text.len(), + "didn't parse all text.\nParsed:\n{}\n\nAll:\n{}\n", + &text[..len], + text + ); + + for (token, msg) in lexed.errors() { + let pos = lexed.text_start(token); + let err = "ERROR"; + errors.push(format!("{err}@{pos}: {msg}\n")); + } + + let has_errors = !errors.is_empty(); + if has_errors { + buf.push_str("---\n"); + for e in errors { + buf.push_str(&e); + } + } + (buf, has_errors) +} diff --git a/crates/squawk_parser/tests/utils.rs b/crates/squawk_parser/tests/utils.rs deleted file mode 100644 index 785df5ec..00000000 --- a/crates/squawk_parser/tests/utils.rs +++ /dev/null @@ -1,61 +0,0 @@ -use std::fmt::Write; - -use squawk_parser::{parse, LexedStr}; - -pub(crate) fn parse_text(text: &str) -> (String, bool) { - let lexed = LexedStr::new(text); - let input = lexed.to_input(); - let output = parse(&input); - - let mut buf = String::new(); - let mut errors = Vec::new(); - let mut indent = String::new(); - let mut depth = 0; - let mut len = 0; - lexed.intersperse_trivia(&output, &mut |step| match step { - squawk_parser::StrStep::Token { kind, text } => { - assert!(depth > 0); - len += text.len(); - writeln!(buf, "{indent}{kind:?} {text:?}").unwrap(); - } - squawk_parser::StrStep::Enter { kind } => { - assert!(depth > 0 || len == 0); - depth += 1; - writeln!(buf, "{indent}{kind:?}").unwrap(); - indent.push_str(" "); - } - squawk_parser::StrStep::Exit => { - assert!(depth > 0); - depth -= 1; - indent.pop(); - indent.pop(); - } - squawk_parser::StrStep::Error { msg, pos } => { - assert!(depth > 0); - let err = "ERROR"; - errors.push(format!("{err}@{pos}: {msg}\n")); - } - }); - assert_eq!( - len, - text.len(), - "didn't parse all text.\nParsed:\n{}\n\nAll:\n{}\n", - &text[..len], - text - ); - - for (token, msg) in lexed.errors() { - let pos = lexed.text_start(token); - let err = "ERROR"; - errors.push(format!("{err}@{pos}: {msg}\n")); - } - - let has_errors = !errors.is_empty(); - if has_errors { - buf.push_str("---\n"); - for e in errors { - buf.push_str(&e); - } - } - (buf, has_errors) -} 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..022904db --- /dev/null +++ b/crates/squawk_syntax/src/ast/generated/nodes.rs @@ -0,0 +1,16966 @@ +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 collate(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn constraints(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn if_not_exists(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[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) + } +} + +#[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 Aggregate { + pub(crate) syntax: SyntaxNode, +} +impl Aggregate { + #[inline] + pub fn param_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 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 aggregate(&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 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 option(&self) -> Option { + support::child(&self.syntax) + } + #[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 option(&self) -> Option { + support::child(&self.syntax) + } + #[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 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 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 relation_name(&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 args(&self) -> AstChildren { + support::children(&self.syntax) + } + #[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 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 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 collate(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn constraints(&self) -> AstChildren { + support::children(&self.syntax) + } + #[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 CreateFunction { + pub(crate) syntax: SyntaxNode, +} +impl CreateFunction { + #[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 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 relation_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 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 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 ident_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENT) + } + #[inline] + pub fn parallel_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PARALLEL_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 column_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn index_params(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn using_index(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + } + #[inline] + pub fn key_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::KEY_KW) + } + #[inline] + pub fn primary_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::PRIMARY_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct 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 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 collate(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn ty(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn set_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::SET_KW) + } + #[inline] + pub fn type_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TYPE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct 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 args(&self) -> AstChildren { + support::children(&self.syntax) + } + #[inline] + pub fn l_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::L_PAREN) + } + #[inline] + pub fn r_paren_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::R_PAREN) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct 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 name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn with_timezone(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn without_timezone(&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) + } +} + +#[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 Truncate { + pub(crate) syntax: SyntaxNode, +} +impl Truncate { + #[inline] + pub fn table_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn cascade_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CASCADE_KW) + } + #[inline] + pub fn continue_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONTINUE_KW) + } + #[inline] + pub fn identity_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::IDENTITY_KW) + } + #[inline] + pub fn restart_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTART_KW) + } + #[inline] + pub fn restrict_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::RESTRICT_KW) + } + #[inline] + pub fn table_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TABLE_KW) + } + #[inline] + pub fn truncate_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::TRUNCATE_KW) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub 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 column_list(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn name_ref(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn using_index(&self) -> Option { + support::child(&self.syntax) + } + #[inline] + pub fn constraint_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW) + } + #[inline] + pub fn distinct_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::DISTINCT_KW) + } + #[inline] + pub fn not_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NOT_KW) + } + #[inline] + pub fn nulls_token(&self) -> Option { + support::token(&self.syntax, SyntaxKind::NULLS_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 AlterColumnOption { + AddGenerated(AddGenerated), + DropDefault(DropDefault), + DropExpression(DropExpression), + DropIdentity(DropIdentity), + DropNotNull(DropNotNull), + ResetOptions(ResetOptions), + Restart(Restart), + SetCompression(SetCompression), + SetDefault(SetDefault), + SetExpression(SetExpression), + SetGenerated(SetGenerated), + SetGeneratedOptions(SetGeneratedOptions), + SetNotNull(SetNotNull), + SetOptions(SetOptions), + SetSequenceOption(SetSequenceOption), + SetStatistics(SetStatistics), + SetStorage(SetStorage), + SetType(SetType), +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum AlterDomainAction { + AddConstraint(AddConstraint), + DropConstraint(DropConstraint), + DropDefault(DropDefault), + DropNotNull(DropNotNull), + OwnerTo(OwnerTo), + RenameConstraint(RenameConstraint), + RenameTo(RenameTo), + SetDefault(SetDefault), + SetNotNull(SetNotNull), + SetSchema(SetSchema), + ValidateConstraint(ValidateConstraint), +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum 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), + CreateFunction(CreateFunction), + 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), + PrepareTransactionStmt(PrepareTransactionStmt), + ReleaseSavepointStmt(ReleaseSavepointStmt), + RevokeStmt(RevokeStmt), + Rollback(Rollback), + SavepointStmt(SavepointStmt), + Select(Select), + TableStmt(TableStmt), + Truncate(Truncate), + 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 Aggregate { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::AGGREGATE + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } +} +impl AstNode for Alias { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::ALIAS + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } +} +impl AstNode for 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 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 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 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 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 CreateFunction { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::CREATE_FUNCTION + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } +} +impl AstNode for 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 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 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 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 Truncate { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + kind == SyntaxKind::TRUNCATE + } + #[inline] + fn cast(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 AlterColumnOption { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + matches!( + kind, + SyntaxKind::ADD_GENERATED + | SyntaxKind::DROP_DEFAULT + | SyntaxKind::DROP_EXPRESSION + | SyntaxKind::DROP_IDENTITY + | SyntaxKind::DROP_NOT_NULL + | SyntaxKind::RESET_OPTIONS + | SyntaxKind::RESTART + | SyntaxKind::SET_COMPRESSION + | SyntaxKind::SET_DEFAULT + | SyntaxKind::SET_EXPRESSION + | SyntaxKind::SET_GENERATED + | SyntaxKind::SET_GENERATED_OPTIONS + | SyntaxKind::SET_NOT_NULL + | SyntaxKind::SET_OPTIONS + | SyntaxKind::SET_SEQUENCE_OPTION + | SyntaxKind::SET_STATISTICS + | SyntaxKind::SET_STORAGE + | SyntaxKind::SET_TYPE + ) + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option { + let res = match syntax.kind() { + SyntaxKind::ADD_GENERATED => AlterColumnOption::AddGenerated(AddGenerated { syntax }), + SyntaxKind::DROP_DEFAULT => AlterColumnOption::DropDefault(DropDefault { syntax }), + SyntaxKind::DROP_EXPRESSION => { + AlterColumnOption::DropExpression(DropExpression { syntax }) + } + SyntaxKind::DROP_IDENTITY => AlterColumnOption::DropIdentity(DropIdentity { syntax }), + SyntaxKind::DROP_NOT_NULL => AlterColumnOption::DropNotNull(DropNotNull { syntax }), + SyntaxKind::RESET_OPTIONS => AlterColumnOption::ResetOptions(ResetOptions { syntax }), + SyntaxKind::RESTART => AlterColumnOption::Restart(Restart { syntax }), + SyntaxKind::SET_COMPRESSION => { + AlterColumnOption::SetCompression(SetCompression { syntax }) + } + SyntaxKind::SET_DEFAULT => AlterColumnOption::SetDefault(SetDefault { syntax }), + SyntaxKind::SET_EXPRESSION => { + AlterColumnOption::SetExpression(SetExpression { syntax }) + } + SyntaxKind::SET_GENERATED => AlterColumnOption::SetGenerated(SetGenerated { syntax }), + SyntaxKind::SET_GENERATED_OPTIONS => { + AlterColumnOption::SetGeneratedOptions(SetGeneratedOptions { syntax }) + } + SyntaxKind::SET_NOT_NULL => AlterColumnOption::SetNotNull(SetNotNull { syntax }), + SyntaxKind::SET_OPTIONS => AlterColumnOption::SetOptions(SetOptions { syntax }), + SyntaxKind::SET_SEQUENCE_OPTION => { + AlterColumnOption::SetSequenceOption(SetSequenceOption { syntax }) + } + SyntaxKind::SET_STATISTICS => { + AlterColumnOption::SetStatistics(SetStatistics { syntax }) + } + SyntaxKind::SET_STORAGE => AlterColumnOption::SetStorage(SetStorage { syntax }), + SyntaxKind::SET_TYPE => AlterColumnOption::SetType(SetType { syntax }), + _ => { + return None; + } + }; + Some(res) + } + #[inline] + fn syntax(&self) -> &SyntaxNode { + match self { + AlterColumnOption::AddGenerated(it) => &it.syntax, + AlterColumnOption::DropDefault(it) => &it.syntax, + AlterColumnOption::DropExpression(it) => &it.syntax, + AlterColumnOption::DropIdentity(it) => &it.syntax, + AlterColumnOption::DropNotNull(it) => &it.syntax, + AlterColumnOption::ResetOptions(it) => &it.syntax, + AlterColumnOption::Restart(it) => &it.syntax, + AlterColumnOption::SetCompression(it) => &it.syntax, + AlterColumnOption::SetDefault(it) => &it.syntax, + AlterColumnOption::SetExpression(it) => &it.syntax, + AlterColumnOption::SetGenerated(it) => &it.syntax, + AlterColumnOption::SetGeneratedOptions(it) => &it.syntax, + AlterColumnOption::SetNotNull(it) => &it.syntax, + AlterColumnOption::SetOptions(it) => &it.syntax, + AlterColumnOption::SetSequenceOption(it) => &it.syntax, + AlterColumnOption::SetStatistics(it) => &it.syntax, + AlterColumnOption::SetStorage(it) => &it.syntax, + AlterColumnOption::SetType(it) => &it.syntax, + } + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: AddGenerated) -> AlterColumnOption { + AlterColumnOption::AddGenerated(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: DropDefault) -> AlterColumnOption { + AlterColumnOption::DropDefault(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: DropExpression) -> AlterColumnOption { + AlterColumnOption::DropExpression(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: DropIdentity) -> AlterColumnOption { + AlterColumnOption::DropIdentity(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: DropNotNull) -> AlterColumnOption { + AlterColumnOption::DropNotNull(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: ResetOptions) -> AlterColumnOption { + AlterColumnOption::ResetOptions(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: Restart) -> AlterColumnOption { + AlterColumnOption::Restart(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: SetCompression) -> AlterColumnOption { + AlterColumnOption::SetCompression(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: SetDefault) -> AlterColumnOption { + AlterColumnOption::SetDefault(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: SetExpression) -> AlterColumnOption { + AlterColumnOption::SetExpression(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: SetGenerated) -> AlterColumnOption { + AlterColumnOption::SetGenerated(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: SetGeneratedOptions) -> AlterColumnOption { + AlterColumnOption::SetGeneratedOptions(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: SetNotNull) -> AlterColumnOption { + AlterColumnOption::SetNotNull(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: SetOptions) -> AlterColumnOption { + AlterColumnOption::SetOptions(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: SetSequenceOption) -> AlterColumnOption { + AlterColumnOption::SetSequenceOption(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: SetStatistics) -> AlterColumnOption { + AlterColumnOption::SetStatistics(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: SetStorage) -> AlterColumnOption { + AlterColumnOption::SetStorage(node) + } +} +impl From for AlterColumnOption { + #[inline] + fn from(node: SetType) -> AlterColumnOption { + AlterColumnOption::SetType(node) + } +} +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_FUNCTION + | 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::PREPARE_TRANSACTION_STMT + | SyntaxKind::RELEASE_SAVEPOINT_STMT + | SyntaxKind::REVOKE_STMT + | SyntaxKind::ROLLBACK + | SyntaxKind::SAVEPOINT_STMT + | SyntaxKind::SELECT + | SyntaxKind::TABLE_STMT + | SyntaxKind::TRUNCATE + | 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_FUNCTION => Stmt::CreateFunction(CreateFunction { 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::PREPARE_TRANSACTION_STMT => { + Stmt::PrepareTransactionStmt(PrepareTransactionStmt { syntax }) + } + SyntaxKind::RELEASE_SAVEPOINT_STMT => { + Stmt::ReleaseSavepointStmt(ReleaseSavepointStmt { syntax }) + } + SyntaxKind::REVOKE_STMT => Stmt::RevokeStmt(RevokeStmt { syntax }), + SyntaxKind::ROLLBACK => Stmt::Rollback(Rollback { syntax }), + SyntaxKind::SAVEPOINT_STMT => Stmt::SavepointStmt(SavepointStmt { syntax }), + SyntaxKind::SELECT => Stmt::Select(Select { syntax }), + SyntaxKind::TABLE_STMT => Stmt::TableStmt(TableStmt { syntax }), + SyntaxKind::TRUNCATE => Stmt::Truncate(Truncate { 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::CreateFunction(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::PrepareTransactionStmt(it) => &it.syntax, + Stmt::ReleaseSavepointStmt(it) => &it.syntax, + Stmt::RevokeStmt(it) => &it.syntax, + Stmt::Rollback(it) => &it.syntax, + Stmt::SavepointStmt(it) => &it.syntax, + Stmt::Select(it) => &it.syntax, + Stmt::TableStmt(it) => &it.syntax, + Stmt::Truncate(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: CreateFunction) -> Stmt { + Stmt::CreateFunction(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: PrepareTransactionStmt) -> Stmt { + Stmt::PrepareTransactionStmt(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: SavepointStmt) -> Stmt { + Stmt::SavepointStmt(node) + } +} +impl From