#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub enum Keyword {
Access,
Acks,
Addresses,
All,
Alter,
And,
Any,
Arn,
Arrangement,
Array,
As,
Asc,
At,
Auction,
Authority,
Availability,
Avro,
Aws,
Begin,
Between,
Bigint,
Boolean,
Both,
Bpchar,
Broken,
Broker,
Brokers,
By,
Bytes,
Cardinality,
Cascade,
Case,
Cast,
Certificate,
Chain,
Char,
Character,
Characteristics,
Check,
Client,
Close,
Cluster,
Clusters,
Coalesce,
Collate,
Columns,
Commit,
Committed,
Compaction,
Compute,
Computectl,
Confluent,
Connection,
Connections,
Constraint,
Copy,
Count,
Counter,
Create,
Createcluster,
Createdb,
Createrole,
Cross,
Csv,
Current,
Cursor,
Database,
Databases,
Datums,
Day,
Days,
Deallocate,
Debezium,
Debug,
Debugging,
Dec,
Decimal,
Declare,
Decorrelated,
Default,
Delete,
Delimited,
Delimiter,
Desc,
Details,
Discard,
Disk,
Distinct,
Dot,
Double,
Drop,
Effort,
Element,
Else,
Enable,
End,
Endpoint,
Enforced,
Envelope,
Error,
Escape,
Except,
Execute,
Exists,
Expected,
Explain,
Expose,
Extract,
Factor,
False,
Fetch,
Fields,
Filter,
First,
Float,
Following,
For,
Foreign,
Format,
Forward,
From,
Full,
Fullname,
Function,
Generator,
Grant,
Greatest,
Group,
Groups,
Having,
Header,
Headers,
Hold,
Host,
Hour,
Hours,
Id,
Idempotence,
Idle,
If,
Ignore,
Ilike,
In,
Include,
Index,
Indexes,
Info,
Inherit,
Inline,
Inner,
Insert,
Inspect,
Int,
Integer,
Intersect,
Interval,
Into,
Introspection,
Is,
Isnull,
Isolation,
Join,
Json,
Kafka,
Key,
Keys,
Last,
Lateral,
Latest,
Leading,
Least,
Left,
Level,
Like,
Limit,
List,
Load,
Local,
Log,
Logical,
Login,
Managed,
Map,
Marketing,
Materialize,
Materialized,
Max,
Mechanisms,
Merge,
Message,
Metadata,
Minute,
Minutes,
Mode,
Month,
Months,
Ms,
Mutually,
Name,
Names,
Natural,
Next,
No,
Nocreatecluster,
Nocreatedb,
Nocreaterole,
Noinherit,
Nologin,
None,
Nosuperuser,
Not,
Notice,
Null,
Nullif,
Nulls,
Objects,
Of,
Offset,
On,
Only,
Operator,
Optimized,
Optimizer,
Options,
Or,
Order,
Ordinality,
Outer,
Over,
Owned,
Owner,
Partition,
Password,
Physical,
Plan,
Plans,
Port,
Position,
Postgres,
Preceding,
Precision,
Prefix,
Prepare,
Primary,
Privatelink,
Privileges,
Progress,
Protobuf,
Publication,
Query,
Quote,
Raise,
Range,
Raw,
Read,
Real,
Reassign,
Recursion,
Recursive,
References,
Refresh,
Regex,
Region,
Registry,
Rename,
Repeatable,
Replace,
Replica,
Replicas,
Replication,
Reset,
Respect,
Restrict,
Retention,
Return,
Returning,
Revoke,
Right,
Role,
Roles,
Rollback,
Rotate,
Row,
Rows,
Sasl,
Scale,
Schema,
Schemas,
Script,
Second,
Seconds,
Secret,
Secrets,
Seed,
Select,
Sequences,
Serializable,
Service,
Session,
Set,
Shard,
Show,
Sink,
Sinks,
Size,
Smallint,
Snapshot,
Some,
Source,
Sources,
Ssh,
Ssl,
Start,
Stdin,
Stdout,
Storage,
Storagectl,
Strategy,
Strict,
String,
Subscribe,
Subsource,
Subsources,
Substring,
Superuser,
System,
Table,
Tables,
Tail,
Temp,
Temporary,
Test,
Text,
Then,
Tick,
Ties,
Time,
Timeline,
Timeout,
Timestamp,
To,
Token,
Topic,
Tpch,
Trace,
Trailing,
Transaction,
Trim,
True,
Tunnel,
Type,
Types,
Unbounded,
Uncommitted,
Union,
Unique,
Unknown,
Up,
Update,
Upsert,
Url,
Usage,
User,
Username,
Users,
Using,
Value,
Values,
Varchar,
Varying,
View,
Views,
Warning,
When,
Where,
Window,
Wire,
With,
Within,
Without,
Work,
Workers,
Write,
Year,
Years,
Zone,
Zones,
}
impl Keyword {
pub fn as_str(&self) -> &'static str {
match self {
Keyword::Access => "ACCESS",
Keyword::Acks => "ACKS",
Keyword::Addresses => "ADDRESSES",
Keyword::All => "ALL",
Keyword::Alter => "ALTER",
Keyword::And => "AND",
Keyword::Any => "ANY",
Keyword::Arn => "ARN",
Keyword::Arrangement => "ARRANGEMENT",
Keyword::Array => "ARRAY",
Keyword::As => "AS",
Keyword::Asc => "ASC",
Keyword::At => "AT",
Keyword::Auction => "AUCTION",
Keyword::Authority => "AUTHORITY",
Keyword::Availability => "AVAILABILITY",
Keyword::Avro => "AVRO",
Keyword::Aws => "AWS",
Keyword::Begin => "BEGIN",
Keyword::Between => "BETWEEN",
Keyword::Bigint => "BIGINT",
Keyword::Boolean => "BOOLEAN",
Keyword::Both => "BOTH",
Keyword::Bpchar => "BPCHAR",
Keyword::Broken => "BROKEN",
Keyword::Broker => "BROKER",
Keyword::Brokers => "BROKERS",
Keyword::By => "BY",
Keyword::Bytes => "BYTES",
Keyword::Cardinality => "CARDINALITY",
Keyword::Cascade => "CASCADE",
Keyword::Case => "CASE",
Keyword::Cast => "CAST",
Keyword::Certificate => "CERTIFICATE",
Keyword::Chain => "CHAIN",
Keyword::Char => "CHAR",
Keyword::Character => "CHARACTER",
Keyword::Characteristics => "CHARACTERISTICS",
Keyword::Check => "CHECK",
Keyword::Client => "CLIENT",
Keyword::Close => "CLOSE",
Keyword::Cluster => "CLUSTER",
Keyword::Clusters => "CLUSTERS",
Keyword::Coalesce => "COALESCE",
Keyword::Collate => "COLLATE",
Keyword::Columns => "COLUMNS",
Keyword::Commit => "COMMIT",
Keyword::Committed => "COMMITTED",
Keyword::Compaction => "COMPACTION",
Keyword::Compute => "COMPUTE",
Keyword::Computectl => "COMPUTECTL",
Keyword::Confluent => "CONFLUENT",
Keyword::Connection => "CONNECTION",
Keyword::Connections => "CONNECTIONS",
Keyword::Constraint => "CONSTRAINT",
Keyword::Copy => "COPY",
Keyword::Count => "COUNT",
Keyword::Counter => "COUNTER",
Keyword::Create => "CREATE",
Keyword::Createcluster => "CREATECLUSTER",
Keyword::Createdb => "CREATEDB",
Keyword::Createrole => "CREATEROLE",
Keyword::Cross => "CROSS",
Keyword::Csv => "CSV",
Keyword::Current => "CURRENT",
Keyword::Cursor => "CURSOR",
Keyword::Database => "DATABASE",
Keyword::Databases => "DATABASES",
Keyword::Datums => "DATUMS",
Keyword::Day => "DAY",
Keyword::Days => "DAYS",
Keyword::Deallocate => "DEALLOCATE",
Keyword::Debezium => "DEBEZIUM",
Keyword::Debug => "DEBUG",
Keyword::Debugging => "DEBUGGING",
Keyword::Dec => "DEC",
Keyword::Decimal => "DECIMAL",
Keyword::Declare => "DECLARE",
Keyword::Decorrelated => "DECORRELATED",
Keyword::Default => "DEFAULT",
Keyword::Delete => "DELETE",
Keyword::Delimited => "DELIMITED",
Keyword::Delimiter => "DELIMITER",
Keyword::Desc => "DESC",
Keyword::Details => "DETAILS",
Keyword::Discard => "DISCARD",
Keyword::Disk => "DISK",
Keyword::Distinct => "DISTINCT",
Keyword::Dot => "DOT",
Keyword::Double => "DOUBLE",
Keyword::Drop => "DROP",
Keyword::Effort => "EFFORT",
Keyword::Element => "ELEMENT",
Keyword::Else => "ELSE",
Keyword::Enable => "ENABLE",
Keyword::End => "END",
Keyword::Endpoint => "ENDPOINT",
Keyword::Enforced => "ENFORCED",
Keyword::Envelope => "ENVELOPE",
Keyword::Error => "ERROR",
Keyword::Escape => "ESCAPE",
Keyword::Except => "EXCEPT",
Keyword::Execute => "EXECUTE",
Keyword::Exists => "EXISTS",
Keyword::Expected => "EXPECTED",
Keyword::Explain => "EXPLAIN",
Keyword::Expose => "EXPOSE",
Keyword::Extract => "EXTRACT",
Keyword::Factor => "FACTOR",
Keyword::False => "FALSE",
Keyword::Fetch => "FETCH",
Keyword::Fields => "FIELDS",
Keyword::Filter => "FILTER",
Keyword::First => "FIRST",
Keyword::Float => "FLOAT",
Keyword::Following => "FOLLOWING",
Keyword::For => "FOR",
Keyword::Foreign => "FOREIGN",
Keyword::Format => "FORMAT",
Keyword::Forward => "FORWARD",
Keyword::From => "FROM",
Keyword::Full => "FULL",
Keyword::Fullname => "FULLNAME",
Keyword::Function => "FUNCTION",
Keyword::Generator => "GENERATOR",
Keyword::Grant => "GRANT",
Keyword::Greatest => "GREATEST",
Keyword::Group => "GROUP",
Keyword::Groups => "GROUPS",
Keyword::Having => "HAVING",
Keyword::Header => "HEADER",
Keyword::Headers => "HEADERS",
Keyword::Hold => "HOLD",
Keyword::Host => "HOST",
Keyword::Hour => "HOUR",
Keyword::Hours => "HOURS",
Keyword::Id => "ID",
Keyword::Idempotence => "IDEMPOTENCE",
Keyword::Idle => "IDLE",
Keyword::If => "IF",
Keyword::Ignore => "IGNORE",
Keyword::Ilike => "ILIKE",
Keyword::In => "IN",
Keyword::Include => "INCLUDE",
Keyword::Index => "INDEX",
Keyword::Indexes => "INDEXES",
Keyword::Info => "INFO",
Keyword::Inherit => "INHERIT",
Keyword::Inline => "INLINE",
Keyword::Inner => "INNER",
Keyword::Insert => "INSERT",
Keyword::Inspect => "INSPECT",
Keyword::Int => "INT",
Keyword::Integer => "INTEGER",
Keyword::Intersect => "INTERSECT",
Keyword::Interval => "INTERVAL",
Keyword::Into => "INTO",
Keyword::Introspection => "INTROSPECTION",
Keyword::Is => "IS",
Keyword::Isnull => "ISNULL",
Keyword::Isolation => "ISOLATION",
Keyword::Join => "JOIN",
Keyword::Json => "JSON",
Keyword::Kafka => "KAFKA",
Keyword::Key => "KEY",
Keyword::Keys => "KEYS",
Keyword::Last => "LAST",
Keyword::Lateral => "LATERAL",
Keyword::Latest => "LATEST",
Keyword::Leading => "LEADING",
Keyword::Least => "LEAST",
Keyword::Left => "LEFT",
Keyword::Level => "LEVEL",
Keyword::Like => "LIKE",
Keyword::Limit => "LIMIT",
Keyword::List => "LIST",
Keyword::Load => "LOAD",
Keyword::Local => "LOCAL",
Keyword::Log => "LOG",
Keyword::Logical => "LOGICAL",
Keyword::Login => "LOGIN",
Keyword::Managed => "MANAGED",
Keyword::Map => "MAP",
Keyword::Marketing => "MARKETING",
Keyword::Materialize => "MATERIALIZE",
Keyword::Materialized => "MATERIALIZED",
Keyword::Max => "MAX",
Keyword::Mechanisms => "MECHANISMS",
Keyword::Merge => "MERGE",
Keyword::Message => "MESSAGE",
Keyword::Metadata => "METADATA",
Keyword::Minute => "MINUTE",
Keyword::Minutes => "MINUTES",
Keyword::Mode => "MODE",
Keyword::Month => "MONTH",
Keyword::Months => "MONTHS",
Keyword::Ms => "MS",
Keyword::Mutually => "MUTUALLY",
Keyword::Name => "NAME",
Keyword::Names => "NAMES",
Keyword::Natural => "NATURAL",
Keyword::Next => "NEXT",
Keyword::No => "NO",
Keyword::Nocreatecluster => "NOCREATECLUSTER",
Keyword::Nocreatedb => "NOCREATEDB",
Keyword::Nocreaterole => "NOCREATEROLE",
Keyword::Noinherit => "NOINHERIT",
Keyword::Nologin => "NOLOGIN",
Keyword::None => "NONE",
Keyword::Nosuperuser => "NOSUPERUSER",
Keyword::Not => "NOT",
Keyword::Notice => "NOTICE",
Keyword::Null => "NULL",
Keyword::Nullif => "NULLIF",
Keyword::Nulls => "NULLS",
Keyword::Objects => "OBJECTS",
Keyword::Of => "OF",
Keyword::Offset => "OFFSET",
Keyword::On => "ON",
Keyword::Only => "ONLY",
Keyword::Operator => "OPERATOR",
Keyword::Optimized => "OPTIMIZED",
Keyword::Optimizer => "OPTIMIZER",
Keyword::Options => "OPTIONS",
Keyword::Or => "OR",
Keyword::Order => "ORDER",
Keyword::Ordinality => "ORDINALITY",
Keyword::Outer => "OUTER",
Keyword::Over => "OVER",
Keyword::Owned => "OWNED",
Keyword::Owner => "OWNER",
Keyword::Partition => "PARTITION",
Keyword::Password => "PASSWORD",
Keyword::Physical => "PHYSICAL",
Keyword::Plan => "PLAN",
Keyword::Plans => "PLANS",
Keyword::Port => "PORT",
Keyword::Position => "POSITION",
Keyword::Postgres => "POSTGRES",
Keyword::Preceding => "PRECEDING",
Keyword::Precision => "PRECISION",
Keyword::Prefix => "PREFIX",
Keyword::Prepare => "PREPARE",
Keyword::Primary => "PRIMARY",
Keyword::Privatelink => "PRIVATELINK",
Keyword::Privileges => "PRIVILEGES",
Keyword::Progress => "PROGRESS",
Keyword::Protobuf => "PROTOBUF",
Keyword::Publication => "PUBLICATION",
Keyword::Query => "QUERY",
Keyword::Quote => "QUOTE",
Keyword::Raise => "RAISE",
Keyword::Range => "RANGE",
Keyword::Raw => "RAW",
Keyword::Read => "READ",
Keyword::Real => "REAL",
Keyword::Reassign => "REASSIGN",
Keyword::Recursion => "RECURSION",
Keyword::Recursive => "RECURSIVE",
Keyword::References => "REFERENCES",
Keyword::Refresh => "REFRESH",
Keyword::Regex => "REGEX",
Keyword::Region => "REGION",
Keyword::Registry => "REGISTRY",
Keyword::Rename => "RENAME",
Keyword::Repeatable => "REPEATABLE",
Keyword::Replace => "REPLACE",
Keyword::Replica => "REPLICA",
Keyword::Replicas => "REPLICAS",
Keyword::Replication => "REPLICATION",
Keyword::Reset => "RESET",
Keyword::Respect => "RESPECT",
Keyword::Restrict => "RESTRICT",
Keyword::Retention => "RETENTION",
Keyword::Return => "RETURN",
Keyword::Returning => "RETURNING",
Keyword::Revoke => "REVOKE",
Keyword::Right => "RIGHT",
Keyword::Role => "ROLE",
Keyword::Roles => "ROLES",
Keyword::Rollback => "ROLLBACK",
Keyword::Rotate => "ROTATE",
Keyword::Row => "ROW",
Keyword::Rows => "ROWS",
Keyword::Sasl => "SASL",
Keyword::Scale => "SCALE",
Keyword::Schema => "SCHEMA",
Keyword::Schemas => "SCHEMAS",
Keyword::Script => "SCRIPT",
Keyword::Second => "SECOND",
Keyword::Seconds => "SECONDS",
Keyword::Secret => "SECRET",
Keyword::Secrets => "SECRETS",
Keyword::Seed => "SEED",
Keyword::Select => "SELECT",
Keyword::Sequences => "SEQUENCES",
Keyword::Serializable => "SERIALIZABLE",
Keyword::Service => "SERVICE",
Keyword::Session => "SESSION",
Keyword::Set => "SET",
Keyword::Shard => "SHARD",
Keyword::Show => "SHOW",
Keyword::Sink => "SINK",
Keyword::Sinks => "SINKS",
Keyword::Size => "SIZE",
Keyword::Smallint => "SMALLINT",
Keyword::Snapshot => "SNAPSHOT",
Keyword::Some => "SOME",
Keyword::Source => "SOURCE",
Keyword::Sources => "SOURCES",
Keyword::Ssh => "SSH",
Keyword::Ssl => "SSL",
Keyword::Start => "START",
Keyword::Stdin => "STDIN",
Keyword::Stdout => "STDOUT",
Keyword::Storage => "STORAGE",
Keyword::Storagectl => "STORAGECTL",
Keyword::Strategy => "STRATEGY",
Keyword::Strict => "STRICT",
Keyword::String => "STRING",
Keyword::Subscribe => "SUBSCRIBE",
Keyword::Subsource => "SUBSOURCE",
Keyword::Subsources => "SUBSOURCES",
Keyword::Substring => "SUBSTRING",
Keyword::Superuser => "SUPERUSER",
Keyword::System => "SYSTEM",
Keyword::Table => "TABLE",
Keyword::Tables => "TABLES",
Keyword::Tail => "TAIL",
Keyword::Temp => "TEMP",
Keyword::Temporary => "TEMPORARY",
Keyword::Test => "TEST",
Keyword::Text => "TEXT",
Keyword::Then => "THEN",
Keyword::Tick => "TICK",
Keyword::Ties => "TIES",
Keyword::Time => "TIME",
Keyword::Timeline => "TIMELINE",
Keyword::Timeout => "TIMEOUT",
Keyword::Timestamp => "TIMESTAMP",
Keyword::To => "TO",
Keyword::Token => "TOKEN",
Keyword::Topic => "TOPIC",
Keyword::Tpch => "TPCH",
Keyword::Trace => "TRACE",
Keyword::Trailing => "TRAILING",
Keyword::Transaction => "TRANSACTION",
Keyword::Trim => "TRIM",
Keyword::True => "TRUE",
Keyword::Tunnel => "TUNNEL",
Keyword::Type => "TYPE",
Keyword::Types => "TYPES",
Keyword::Unbounded => "UNBOUNDED",
Keyword::Uncommitted => "UNCOMMITTED",
Keyword::Union => "UNION",
Keyword::Unique => "UNIQUE",
Keyword::Unknown => "UNKNOWN",
Keyword::Up => "UP",
Keyword::Update => "UPDATE",
Keyword::Upsert => "UPSERT",
Keyword::Url => "URL",
Keyword::Usage => "USAGE",
Keyword::User => "USER",
Keyword::Username => "USERNAME",
Keyword::Users => "USERS",
Keyword::Using => "USING",
Keyword::Value => "VALUE",
Keyword::Values => "VALUES",
Keyword::Varchar => "VARCHAR",
Keyword::Varying => "VARYING",
Keyword::View => "VIEW",
Keyword::Views => "VIEWS",
Keyword::Warning => "WARNING",
Keyword::When => "WHEN",
Keyword::Where => "WHERE",
Keyword::Window => "WINDOW",
Keyword::Wire => "WIRE",
Keyword::With => "WITH",
Keyword::Within => "WITHIN",
Keyword::Without => "WITHOUT",
Keyword::Work => "WORK",
Keyword::Workers => "WORKERS",
Keyword::Write => "WRITE",
Keyword::Year => "YEAR",
Keyword::Years => "YEARS",
Keyword::Zone => "ZONE",
Keyword::Zones => "ZONES",
}
}
}
pub const ACCESS: Keyword = Keyword::Access;
pub const ACKS: Keyword = Keyword::Acks;
pub const ADDRESSES: Keyword = Keyword::Addresses;
pub const ALL: Keyword = Keyword::All;
pub const ALTER: Keyword = Keyword::Alter;
pub const AND: Keyword = Keyword::And;
pub const ANY: Keyword = Keyword::Any;
pub const ARN: Keyword = Keyword::Arn;
pub const ARRANGEMENT: Keyword = Keyword::Arrangement;
pub const ARRAY: Keyword = Keyword::Array;
pub const AS: Keyword = Keyword::As;
pub const ASC: Keyword = Keyword::Asc;
pub const AT: Keyword = Keyword::At;
pub const AUCTION: Keyword = Keyword::Auction;
pub const AUTHORITY: Keyword = Keyword::Authority;
pub const AVAILABILITY: Keyword = Keyword::Availability;
pub const AVRO: Keyword = Keyword::Avro;
pub const AWS: Keyword = Keyword::Aws;
pub const BEGIN: Keyword = Keyword::Begin;
pub const BETWEEN: Keyword = Keyword::Between;
pub const BIGINT: Keyword = Keyword::Bigint;
pub const BOOLEAN: Keyword = Keyword::Boolean;
pub const BOTH: Keyword = Keyword::Both;
pub const BPCHAR: Keyword = Keyword::Bpchar;
pub const BROKEN: Keyword = Keyword::Broken;
pub const BROKER: Keyword = Keyword::Broker;
pub const BROKERS: Keyword = Keyword::Brokers;
pub const BY: Keyword = Keyword::By;
pub const BYTES: Keyword = Keyword::Bytes;
pub const CARDINALITY: Keyword = Keyword::Cardinality;
pub const CASCADE: Keyword = Keyword::Cascade;
pub const CASE: Keyword = Keyword::Case;
pub const CAST: Keyword = Keyword::Cast;
pub const CERTIFICATE: Keyword = Keyword::Certificate;
pub const CHAIN: Keyword = Keyword::Chain;
pub const CHAR: Keyword = Keyword::Char;
pub const CHARACTER: Keyword = Keyword::Character;
pub const CHARACTERISTICS: Keyword = Keyword::Characteristics;
pub const CHECK: Keyword = Keyword::Check;
pub const CLIENT: Keyword = Keyword::Client;
pub const CLOSE: Keyword = Keyword::Close;
pub const CLUSTER: Keyword = Keyword::Cluster;
pub const CLUSTERS: Keyword = Keyword::Clusters;
pub const COALESCE: Keyword = Keyword::Coalesce;
pub const COLLATE: Keyword = Keyword::Collate;
pub const COLUMNS: Keyword = Keyword::Columns;
pub const COMMIT: Keyword = Keyword::Commit;
pub const COMMITTED: Keyword = Keyword::Committed;
pub const COMPACTION: Keyword = Keyword::Compaction;
pub const COMPUTE: Keyword = Keyword::Compute;
pub const COMPUTECTL: Keyword = Keyword::Computectl;
pub const CONFLUENT: Keyword = Keyword::Confluent;
pub const CONNECTION: Keyword = Keyword::Connection;
pub const CONNECTIONS: Keyword = Keyword::Connections;
pub const CONSTRAINT: Keyword = Keyword::Constraint;
pub const COPY: Keyword = Keyword::Copy;
pub const COUNT: Keyword = Keyword::Count;
pub const COUNTER: Keyword = Keyword::Counter;
pub const CREATE: Keyword = Keyword::Create;
pub const CREATECLUSTER: Keyword = Keyword::Createcluster;
pub const CREATEDB: Keyword = Keyword::Createdb;
pub const CREATEROLE: Keyword = Keyword::Createrole;
pub const CROSS: Keyword = Keyword::Cross;
pub const CSV: Keyword = Keyword::Csv;
pub const CURRENT: Keyword = Keyword::Current;
pub const CURSOR: Keyword = Keyword::Cursor;
pub const DATABASE: Keyword = Keyword::Database;
pub const DATABASES: Keyword = Keyword::Databases;
pub const DATUMS: Keyword = Keyword::Datums;
pub const DAY: Keyword = Keyword::Day;
pub const DAYS: Keyword = Keyword::Days;
pub const DEALLOCATE: Keyword = Keyword::Deallocate;
pub const DEBEZIUM: Keyword = Keyword::Debezium;
pub const DEBUG: Keyword = Keyword::Debug;
pub const DEBUGGING: Keyword = Keyword::Debugging;
pub const DEC: Keyword = Keyword::Dec;
pub const DECIMAL: Keyword = Keyword::Decimal;
pub const DECLARE: Keyword = Keyword::Declare;
pub const DECORRELATED: Keyword = Keyword::Decorrelated;
pub const DEFAULT: Keyword = Keyword::Default;
pub const DELETE: Keyword = Keyword::Delete;
pub const DELIMITED: Keyword = Keyword::Delimited;
pub const DELIMITER: Keyword = Keyword::Delimiter;
pub const DESC: Keyword = Keyword::Desc;
pub const DETAILS: Keyword = Keyword::Details;
pub const DISCARD: Keyword = Keyword::Discard;
pub const DISK: Keyword = Keyword::Disk;
pub const DISTINCT: Keyword = Keyword::Distinct;
pub const DOT: Keyword = Keyword::Dot;
pub const DOUBLE: Keyword = Keyword::Double;
pub const DROP: Keyword = Keyword::Drop;
pub const EFFORT: Keyword = Keyword::Effort;
pub const ELEMENT: Keyword = Keyword::Element;
pub const ELSE: Keyword = Keyword::Else;
pub const ENABLE: Keyword = Keyword::Enable;
pub const END: Keyword = Keyword::End;
pub const ENDPOINT: Keyword = Keyword::Endpoint;
pub const ENFORCED: Keyword = Keyword::Enforced;
pub const ENVELOPE: Keyword = Keyword::Envelope;
pub const ERROR: Keyword = Keyword::Error;
pub const ESCAPE: Keyword = Keyword::Escape;
pub const EXCEPT: Keyword = Keyword::Except;
pub const EXECUTE: Keyword = Keyword::Execute;
pub const EXISTS: Keyword = Keyword::Exists;
pub const EXPECTED: Keyword = Keyword::Expected;
pub const EXPLAIN: Keyword = Keyword::Explain;
pub const EXPOSE: Keyword = Keyword::Expose;
pub const EXTRACT: Keyword = Keyword::Extract;
pub const FACTOR: Keyword = Keyword::Factor;
pub const FALSE: Keyword = Keyword::False;
pub const FETCH: Keyword = Keyword::Fetch;
pub const FIELDS: Keyword = Keyword::Fields;
pub const FILTER: Keyword = Keyword::Filter;
pub const FIRST: Keyword = Keyword::First;
pub const FLOAT: Keyword = Keyword::Float;
pub const FOLLOWING: Keyword = Keyword::Following;
pub const FOR: Keyword = Keyword::For;
pub const FOREIGN: Keyword = Keyword::Foreign;
pub const FORMAT: Keyword = Keyword::Format;
pub const FORWARD: Keyword = Keyword::Forward;
pub const FROM: Keyword = Keyword::From;
pub const FULL: Keyword = Keyword::Full;
pub const FULLNAME: Keyword = Keyword::Fullname;
pub const FUNCTION: Keyword = Keyword::Function;
pub const GENERATOR: Keyword = Keyword::Generator;
pub const GRANT: Keyword = Keyword::Grant;
pub const GREATEST: Keyword = Keyword::Greatest;
pub const GROUP: Keyword = Keyword::Group;
pub const GROUPS: Keyword = Keyword::Groups;
pub const HAVING: Keyword = Keyword::Having;
pub const HEADER: Keyword = Keyword::Header;
pub const HEADERS: Keyword = Keyword::Headers;
pub const HOLD: Keyword = Keyword::Hold;
pub const HOST: Keyword = Keyword::Host;
pub const HOUR: Keyword = Keyword::Hour;
pub const HOURS: Keyword = Keyword::Hours;
pub const ID: Keyword = Keyword::Id;
pub const IDEMPOTENCE: Keyword = Keyword::Idempotence;
pub const IDLE: Keyword = Keyword::Idle;
pub const IF: Keyword = Keyword::If;
pub const IGNORE: Keyword = Keyword::Ignore;
pub const ILIKE: Keyword = Keyword::Ilike;
pub const IN: Keyword = Keyword::In;
pub const INCLUDE: Keyword = Keyword::Include;
pub const INDEX: Keyword = Keyword::Index;
pub const INDEXES: Keyword = Keyword::Indexes;
pub const INFO: Keyword = Keyword::Info;
pub const INHERIT: Keyword = Keyword::Inherit;
pub const INLINE: Keyword = Keyword::Inline;
pub const INNER: Keyword = Keyword::Inner;
pub const INSERT: Keyword = Keyword::Insert;
pub const INSPECT: Keyword = Keyword::Inspect;
pub const INT: Keyword = Keyword::Int;
pub const INTEGER: Keyword = Keyword::Integer;
pub const INTERSECT: Keyword = Keyword::Intersect;
pub const INTERVAL: Keyword = Keyword::Interval;
pub const INTO: Keyword = Keyword::Into;
pub const INTROSPECTION: Keyword = Keyword::Introspection;
pub const IS: Keyword = Keyword::Is;
pub const ISNULL: Keyword = Keyword::Isnull;
pub const ISOLATION: Keyword = Keyword::Isolation;
pub const JOIN: Keyword = Keyword::Join;
pub const JSON: Keyword = Keyword::Json;
pub const KAFKA: Keyword = Keyword::Kafka;
pub const KEY: Keyword = Keyword::Key;
pub const KEYS: Keyword = Keyword::Keys;
pub const LAST: Keyword = Keyword::Last;
pub const LATERAL: Keyword = Keyword::Lateral;
pub const LATEST: Keyword = Keyword::Latest;
pub const LEADING: Keyword = Keyword::Leading;
pub const LEAST: Keyword = Keyword::Least;
pub const LEFT: Keyword = Keyword::Left;
pub const LEVEL: Keyword = Keyword::Level;
pub const LIKE: Keyword = Keyword::Like;
pub const LIMIT: Keyword = Keyword::Limit;
pub const LIST: Keyword = Keyword::List;
pub const LOAD: Keyword = Keyword::Load;
pub const LOCAL: Keyword = Keyword::Local;
pub const LOG: Keyword = Keyword::Log;
pub const LOGICAL: Keyword = Keyword::Logical;
pub const LOGIN: Keyword = Keyword::Login;
pub const MANAGED: Keyword = Keyword::Managed;
pub const MAP: Keyword = Keyword::Map;
pub const MARKETING: Keyword = Keyword::Marketing;
pub const MATERIALIZE: Keyword = Keyword::Materialize;
pub const MATERIALIZED: Keyword = Keyword::Materialized;
pub const MAX: Keyword = Keyword::Max;
pub const MECHANISMS: Keyword = Keyword::Mechanisms;
pub const MERGE: Keyword = Keyword::Merge;
pub const MESSAGE: Keyword = Keyword::Message;
pub const METADATA: Keyword = Keyword::Metadata;
pub const MINUTE: Keyword = Keyword::Minute;
pub const MINUTES: Keyword = Keyword::Minutes;
pub const MODE: Keyword = Keyword::Mode;
pub const MONTH: Keyword = Keyword::Month;
pub const MONTHS: Keyword = Keyword::Months;
pub const MS: Keyword = Keyword::Ms;
pub const MUTUALLY: Keyword = Keyword::Mutually;
pub const NAME: Keyword = Keyword::Name;
pub const NAMES: Keyword = Keyword::Names;
pub const NATURAL: Keyword = Keyword::Natural;
pub const NEXT: Keyword = Keyword::Next;
pub const NO: Keyword = Keyword::No;
pub const NOCREATECLUSTER: Keyword = Keyword::Nocreatecluster;
pub const NOCREATEDB: Keyword = Keyword::Nocreatedb;
pub const NOCREATEROLE: Keyword = Keyword::Nocreaterole;
pub const NOINHERIT: Keyword = Keyword::Noinherit;
pub const NOLOGIN: Keyword = Keyword::Nologin;
pub const NONE: Keyword = Keyword::None;
pub const NOSUPERUSER: Keyword = Keyword::Nosuperuser;
pub const NOT: Keyword = Keyword::Not;
pub const NOTICE: Keyword = Keyword::Notice;
pub const NULL: Keyword = Keyword::Null;
pub const NULLIF: Keyword = Keyword::Nullif;
pub const NULLS: Keyword = Keyword::Nulls;
pub const OBJECTS: Keyword = Keyword::Objects;
pub const OF: Keyword = Keyword::Of;
pub const OFFSET: Keyword = Keyword::Offset;
pub const ON: Keyword = Keyword::On;
pub const ONLY: Keyword = Keyword::Only;
pub const OPERATOR: Keyword = Keyword::Operator;
pub const OPTIMIZED: Keyword = Keyword::Optimized;
pub const OPTIMIZER: Keyword = Keyword::Optimizer;
pub const OPTIONS: Keyword = Keyword::Options;
pub const OR: Keyword = Keyword::Or;
pub const ORDER: Keyword = Keyword::Order;
pub const ORDINALITY: Keyword = Keyword::Ordinality;
pub const OUTER: Keyword = Keyword::Outer;
pub const OVER: Keyword = Keyword::Over;
pub const OWNED: Keyword = Keyword::Owned;
pub const OWNER: Keyword = Keyword::Owner;
pub const PARTITION: Keyword = Keyword::Partition;
pub const PASSWORD: Keyword = Keyword::Password;
pub const PHYSICAL: Keyword = Keyword::Physical;
pub const PLAN: Keyword = Keyword::Plan;
pub const PLANS: Keyword = Keyword::Plans;
pub const PORT: Keyword = Keyword::Port;
pub const POSITION: Keyword = Keyword::Position;
pub const POSTGRES: Keyword = Keyword::Postgres;
pub const PRECEDING: Keyword = Keyword::Preceding;
pub const PRECISION: Keyword = Keyword::Precision;
pub const PREFIX: Keyword = Keyword::Prefix;
pub const PREPARE: Keyword = Keyword::Prepare;
pub const PRIMARY: Keyword = Keyword::Primary;
pub const PRIVATELINK: Keyword = Keyword::Privatelink;
pub const PRIVILEGES: Keyword = Keyword::Privileges;
pub const PROGRESS: Keyword = Keyword::Progress;
pub const PROTOBUF: Keyword = Keyword::Protobuf;
pub const PUBLICATION: Keyword = Keyword::Publication;
pub const QUERY: Keyword = Keyword::Query;
pub const QUOTE: Keyword = Keyword::Quote;
pub const RAISE: Keyword = Keyword::Raise;
pub const RANGE: Keyword = Keyword::Range;
pub const RAW: Keyword = Keyword::Raw;
pub const READ: Keyword = Keyword::Read;
pub const REAL: Keyword = Keyword::Real;
pub const REASSIGN: Keyword = Keyword::Reassign;
pub const RECURSION: Keyword = Keyword::Recursion;
pub const RECURSIVE: Keyword = Keyword::Recursive;
pub const REFERENCES: Keyword = Keyword::References;
pub const REFRESH: Keyword = Keyword::Refresh;
pub const REGEX: Keyword = Keyword::Regex;
pub const REGION: Keyword = Keyword::Region;
pub const REGISTRY: Keyword = Keyword::Registry;
pub const RENAME: Keyword = Keyword::Rename;
pub const REPEATABLE: Keyword = Keyword::Repeatable;
pub const REPLACE: Keyword = Keyword::Replace;
pub const REPLICA: Keyword = Keyword::Replica;
pub const REPLICAS: Keyword = Keyword::Replicas;
pub const REPLICATION: Keyword = Keyword::Replication;
pub const RESET: Keyword = Keyword::Reset;
pub const RESPECT: Keyword = Keyword::Respect;
pub const RESTRICT: Keyword = Keyword::Restrict;
pub const RETENTION: Keyword = Keyword::Retention;
pub const RETURN: Keyword = Keyword::Return;
pub const RETURNING: Keyword = Keyword::Returning;
pub const REVOKE: Keyword = Keyword::Revoke;
pub const RIGHT: Keyword = Keyword::Right;
pub const ROLE: Keyword = Keyword::Role;
pub const ROLES: Keyword = Keyword::Roles;
pub const ROLLBACK: Keyword = Keyword::Rollback;
pub const ROTATE: Keyword = Keyword::Rotate;
pub const ROW: Keyword = Keyword::Row;
pub const ROWS: Keyword = Keyword::Rows;
pub const SASL: Keyword = Keyword::Sasl;
pub const SCALE: Keyword = Keyword::Scale;
pub const SCHEMA: Keyword = Keyword::Schema;
pub const SCHEMAS: Keyword = Keyword::Schemas;
pub const SCRIPT: Keyword = Keyword::Script;
pub const SECOND: Keyword = Keyword::Second;
pub const SECONDS: Keyword = Keyword::Seconds;
pub const SECRET: Keyword = Keyword::Secret;
pub const SECRETS: Keyword = Keyword::Secrets;
pub const SEED: Keyword = Keyword::Seed;
pub const SELECT: Keyword = Keyword::Select;
pub const SEQUENCES: Keyword = Keyword::Sequences;
pub const SERIALIZABLE: Keyword = Keyword::Serializable;
pub const SERVICE: Keyword = Keyword::Service;
pub const SESSION: Keyword = Keyword::Session;
pub const SET: Keyword = Keyword::Set;
pub const SHARD: Keyword = Keyword::Shard;
pub const SHOW: Keyword = Keyword::Show;
pub const SINK: Keyword = Keyword::Sink;
pub const SINKS: Keyword = Keyword::Sinks;
pub const SIZE: Keyword = Keyword::Size;
pub const SMALLINT: Keyword = Keyword::Smallint;
pub const SNAPSHOT: Keyword = Keyword::Snapshot;
pub const SOME: Keyword = Keyword::Some;
pub const SOURCE: Keyword = Keyword::Source;
pub const SOURCES: Keyword = Keyword::Sources;
pub const SSH: Keyword = Keyword::Ssh;
pub const SSL: Keyword = Keyword::Ssl;
pub const START: Keyword = Keyword::Start;
pub const STDIN: Keyword = Keyword::Stdin;
pub const STDOUT: Keyword = Keyword::Stdout;
pub const STORAGE: Keyword = Keyword::Storage;
pub const STORAGECTL: Keyword = Keyword::Storagectl;
pub const STRATEGY: Keyword = Keyword::Strategy;
pub const STRICT: Keyword = Keyword::Strict;
pub const STRING: Keyword = Keyword::String;
pub const SUBSCRIBE: Keyword = Keyword::Subscribe;
pub const SUBSOURCE: Keyword = Keyword::Subsource;
pub const SUBSOURCES: Keyword = Keyword::Subsources;
pub const SUBSTRING: Keyword = Keyword::Substring;
pub const SUPERUSER: Keyword = Keyword::Superuser;
pub const SYSTEM: Keyword = Keyword::System;
pub const TABLE: Keyword = Keyword::Table;
pub const TABLES: Keyword = Keyword::Tables;
pub const TAIL: Keyword = Keyword::Tail;
pub const TEMP: Keyword = Keyword::Temp;
pub const TEMPORARY: Keyword = Keyword::Temporary;
pub const TEST: Keyword = Keyword::Test;
pub const TEXT: Keyword = Keyword::Text;
pub const THEN: Keyword = Keyword::Then;
pub const TICK: Keyword = Keyword::Tick;
pub const TIES: Keyword = Keyword::Ties;
pub const TIME: Keyword = Keyword::Time;
pub const TIMELINE: Keyword = Keyword::Timeline;
pub const TIMEOUT: Keyword = Keyword::Timeout;
pub const TIMESTAMP: Keyword = Keyword::Timestamp;
pub const TO: Keyword = Keyword::To;
pub const TOKEN: Keyword = Keyword::Token;
pub const TOPIC: Keyword = Keyword::Topic;
pub const TPCH: Keyword = Keyword::Tpch;
pub const TRACE: Keyword = Keyword::Trace;
pub const TRAILING: Keyword = Keyword::Trailing;
pub const TRANSACTION: Keyword = Keyword::Transaction;
pub const TRIM: Keyword = Keyword::Trim;
pub const TRUE: Keyword = Keyword::True;
pub const TUNNEL: Keyword = Keyword::Tunnel;
pub const TYPE: Keyword = Keyword::Type;
pub const TYPES: Keyword = Keyword::Types;
pub const UNBOUNDED: Keyword = Keyword::Unbounded;
pub const UNCOMMITTED: Keyword = Keyword::Uncommitted;
pub const UNION: Keyword = Keyword::Union;
pub const UNIQUE: Keyword = Keyword::Unique;
pub const UNKNOWN: Keyword = Keyword::Unknown;
pub const UP: Keyword = Keyword::Up;
pub const UPDATE: Keyword = Keyword::Update;
pub const UPSERT: Keyword = Keyword::Upsert;
pub const URL: Keyword = Keyword::Url;
pub const USAGE: Keyword = Keyword::Usage;
pub const USER: Keyword = Keyword::User;
pub const USERNAME: Keyword = Keyword::Username;
pub const USERS: Keyword = Keyword::Users;
pub const USING: Keyword = Keyword::Using;
pub const VALUE: Keyword = Keyword::Value;
pub const VALUES: Keyword = Keyword::Values;
pub const VARCHAR: Keyword = Keyword::Varchar;
pub const VARYING: Keyword = Keyword::Varying;
pub const VIEW: Keyword = Keyword::View;
pub const VIEWS: Keyword = Keyword::Views;
pub const WARNING: Keyword = Keyword::Warning;
pub const WHEN: Keyword = Keyword::When;
pub const WHERE: Keyword = Keyword::Where;
pub const WINDOW: Keyword = Keyword::Window;
pub const WIRE: Keyword = Keyword::Wire;
pub const WITH: Keyword = Keyword::With;
pub const WITHIN: Keyword = Keyword::Within;
pub const WITHOUT: Keyword = Keyword::Without;
pub const WORK: Keyword = Keyword::Work;
pub const WORKERS: Keyword = Keyword::Workers;
pub const WRITE: Keyword = Keyword::Write;
pub const YEAR: Keyword = Keyword::Year;
pub const YEARS: Keyword = Keyword::Years;
pub const ZONE: Keyword = Keyword::Zone;
pub const ZONES: Keyword = Keyword::Zones;
static KEYWORDS: phf::Map<&'static UncasedStr, Keyword> = ::phf::Map {
key: 12913932095322966823,
disps: &[
(0, 0),
(0, 2),
(0, 16),
(0, 0),
(0, 83),
(0, 26),
(0, 1),
(0, 16),
(1, 111),
(0, 80),
(0, 1),
(0, 1),
(0, 127),
(0, 41),
(0, 6),
(0, 19),
(0, 138),
(0, 164),
(0, 12),
(1, 45),
(0, 0),
(0, 2),
(1, 82),
(1, 252),
(0, 298),
(1, 136),
(0, 4),
(0, 7),
(0, 113),
(1, 230),
(0, 33),
(0, 0),
(0, 124),
(0, 129),
(0, 15),
(5, 165),
(3, 215),
(0, 27),
(1, 255),
(0, 0),
(0, 6),
(0, 0),
(0, 7),
(0, 1),
(1, 322),
(0, 2),
(0, 0),
(0, 174),
(24, 225),
(0, 109),
(1, 170),
(6, 227),
(0, 107),
(1, 73),
(0, 188),
(9, 169),
(0, 3),
(1, 336),
(4, 52),
(0, 101),
(5, 95),
(0, 95),
(2, 184),
(0, 16),
(3, 383),
(9, 67),
(0, 1),
(0, 46),
(0, 94),
(0, 5),
(116, 129),
(0, 381),
(8, 87),
(0, 11),
(0, 310),
(78, 385),
(1, 203),
(7, 153),
],
entries: &[
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Limit") }, Keyword::Limit),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Reassign") }, Keyword::Reassign),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Nocreatedb") }, Keyword::Nocreatedb),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Materialized") }, Keyword::Materialized),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Natural") }, Keyword::Natural),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("True") }, Keyword::True),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Insert") }, Keyword::Insert),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Storage") }, Keyword::Storage),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Createcluster") }, Keyword::Createcluster),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Json") }, Keyword::Json),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Delimited") }, Keyword::Delimited),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("System") }, Keyword::System),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Notice") }, Keyword::Notice),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Least") }, Keyword::Least),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Rows") }, Keyword::Rows),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Upsert") }, Keyword::Upsert),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Ordinality") }, Keyword::Ordinality),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Default") }, Keyword::Default),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Retention") }, Keyword::Retention),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Region") }, Keyword::Region),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Enforced") }, Keyword::Enforced),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Fetch") }, Keyword::Fetch),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Schema") }, Keyword::Schema),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Table") }, Keyword::Table),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Port") }, Keyword::Port),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Both") }, Keyword::Both),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Envelope") }, Keyword::Envelope),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Row") }, Keyword::Row),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Uncommitted") }, Keyword::Uncommitted),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Hours") }, Keyword::Hours),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Commit") }, Keyword::Commit),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Hour") }, Keyword::Hour),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Nullif") }, Keyword::Nullif),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Drop") }, Keyword::Drop),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Trim") }, Keyword::Trim),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Count") }, Keyword::Count),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Protobuf") }, Keyword::Protobuf),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Window") }, Keyword::Window),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Refresh") }, Keyword::Refresh),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Ignore") }, Keyword::Ignore),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Deallocate") }, Keyword::Deallocate),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Roles") }, Keyword::Roles),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Rotate") }, Keyword::Rotate),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Compute") }, Keyword::Compute),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Tunnel") }, Keyword::Tunnel),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Discard") }, Keyword::Discard),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Names") }, Keyword::Names),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Headers") }, Keyword::Headers),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("View") }, Keyword::View),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Counter") }, Keyword::Counter),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Rollback") }, Keyword::Rollback),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Stdout") }, Keyword::Stdout),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Authority") }, Keyword::Authority),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Replace") }, Keyword::Replace),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Group") }, Keyword::Group),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Inherit") }, Keyword::Inherit),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("As") }, Keyword::As),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Test") }, Keyword::Test),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Char") }, Keyword::Char),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Grant") }, Keyword::Grant),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Close") }, Keyword::Close),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Host") }, Keyword::Host),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Size") }, Keyword::Size),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Decorrelated") }, Keyword::Decorrelated),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Sink") }, Keyword::Sink),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Committed") }, Keyword::Committed),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Delete") }, Keyword::Delete),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Join") }, Keyword::Join),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Service") }, Keyword::Service),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Revoke") }, Keyword::Revoke),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Factor") }, Keyword::Factor),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Having") }, Keyword::Having),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Using") }, Keyword::Using),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Forward") }, Keyword::Forward),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("At") }, Keyword::At),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Owner") }, Keyword::Owner),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Scale") }, Keyword::Scale),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Kafka") }, Keyword::Kafka),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Execute") }, Keyword::Execute),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Ms") }, Keyword::Ms),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Timeout") }, Keyword::Timeout),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Debug") }, Keyword::Debug),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Intersect") }, Keyword::Intersect),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Arn") }, Keyword::Arn),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Work") }, Keyword::Work),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Else") }, Keyword::Else),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Type") }, Keyword::Type),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Superuser") }, Keyword::Superuser),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Publication") }, Keyword::Publication),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Temp") }, Keyword::Temp),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("User") }, Keyword::User),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Days") }, Keyword::Days),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Precision") }, Keyword::Precision),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Distinct") }, Keyword::Distinct),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Replicas") }, Keyword::Replicas),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Snapshot") }, Keyword::Snapshot),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Mutually") }, Keyword::Mutually),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Within") }, Keyword::Within),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Range") }, Keyword::Range),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Debezium") }, Keyword::Debezium),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Addresses") }, Keyword::Addresses),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Lateral") }, Keyword::Lateral),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Sequences") }, Keyword::Sequences),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Outer") }, Keyword::Outer),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Tick") }, Keyword::Tick),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Types") }, Keyword::Types),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Year") }, Keyword::Year),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Logical") }, Keyword::Logical),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Float") }, Keyword::Float),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Current") }, Keyword::Current),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Int") }, Keyword::Int),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Copy") }, Keyword::Copy),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Function") }, Keyword::Function),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Createdb") }, Keyword::Createdb),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Subsources") }, Keyword::Subsources),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Second") }, Keyword::Second),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Optimized") }, Keyword::Optimized),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Sasl") }, Keyword::Sasl),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("None") }, Keyword::None),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Collate") }, Keyword::Collate),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Expose") }, Keyword::Expose),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Like") }, Keyword::Like),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Extract") }, Keyword::Extract),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Createrole") }, Keyword::Createrole),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Script") }, Keyword::Script),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Ilike") }, Keyword::Ilike),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Generator") }, Keyword::Generator),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Debugging") }, Keyword::Debugging),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Effort") }, Keyword::Effort),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Id") }, Keyword::Id),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Recursion") }, Keyword::Recursion),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Options") }, Keyword::Options),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Introspection") }, Keyword::Introspection),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Brokers") }, Keyword::Brokers),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Not") }, Keyword::Not),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Expected") }, Keyword::Expected),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Declare") }, Keyword::Declare),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Plan") }, Keyword::Plan),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Avro") }, Keyword::Avro),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Physical") }, Keyword::Physical),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Substring") }, Keyword::Substring),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Null") }, Keyword::Null),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Client") }, Keyword::Client),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Value") }, Keyword::Value),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Offset") }, Keyword::Offset),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("All") }, Keyword::All),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Into") }, Keyword::Into),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Position") }, Keyword::Position),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Format") }, Keyword::Format),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Filter") }, Keyword::Filter),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Seconds") }, Keyword::Seconds),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Months") }, Keyword::Months),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Start") }, Keyword::Start),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Fields") }, Keyword::Fields),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Last") }, Keyword::Last),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Zone") }, Keyword::Zone),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Stdin") }, Keyword::Stdin),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Timestamp") }, Keyword::Timestamp),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Is") }, Keyword::Is),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Mode") }, Keyword::Mode),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Full") }, Keyword::Full),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Postgres") }, Keyword::Postgres),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Timeline") }, Keyword::Timeline),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Integer") }, Keyword::Integer),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Read") }, Keyword::Read),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Schemas") }, Keyword::Schemas),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("By") }, Keyword::By),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Unbounded") }, Keyword::Unbounded),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Cursor") }, Keyword::Cursor),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Optimizer") }, Keyword::Optimizer),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Keys") }, Keyword::Keys),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Fullname") }, Keyword::Fullname),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Message") }, Keyword::Message),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Objects") }, Keyword::Objects),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Isolation") }, Keyword::Isolation),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Varchar") }, Keyword::Varchar),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Partition") }, Keyword::Partition),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Unknown") }, Keyword::Unknown),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Info") }, Keyword::Info),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Idempotence") }, Keyword::Idempotence),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Latest") }, Keyword::Latest),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Source") }, Keyword::Source),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Union") }, Keyword::Union),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Double") }, Keyword::Double),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Query") }, Keyword::Query),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Error") }, Keyword::Error),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Rename") }, Keyword::Rename),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Return") }, Keyword::Return),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Tpch") }, Keyword::Tpch),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Session") }, Keyword::Session),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Recursive") }, Keyword::Recursive),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Write") }, Keyword::Write),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Up") }, Keyword::Up),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Where") }, Keyword::Where),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Broker") }, Keyword::Broker),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Some") }, Keyword::Some),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Max") }, Keyword::Max),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Progress") }, Keyword::Progress),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Foreign") }, Keyword::Foreign),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Set") }, Keyword::Set),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Left") }, Keyword::Left),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Workers") }, Keyword::Workers),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Of") }, Keyword::Of),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Replication") }, Keyword::Replication),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Decimal") }, Keyword::Decimal),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("String") }, Keyword::String),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Real") }, Keyword::Real),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Case") }, Keyword::Case),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Only") }, Keyword::Only),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Enable") }, Keyword::Enable),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Csv") }, Keyword::Csv),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Strategy") }, Keyword::Strategy),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("On") }, Keyword::On),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Update") }, Keyword::Update),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Cluster") }, Keyword::Cluster),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Dot") }, Keyword::Dot),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Prefix") }, Keyword::Prefix),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Role") }, Keyword::Role),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Wire") }, Keyword::Wire),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Privatelink") }, Keyword::Privatelink),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Sources") }, Keyword::Sources),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Level") }, Keyword::Level),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Operator") }, Keyword::Operator),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Hold") }, Keyword::Hold),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Minute") }, Keyword::Minute),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Arrangement") }, Keyword::Arrangement),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Interval") }, Keyword::Interval),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Disk") }, Keyword::Disk),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Indexes") }, Keyword::Indexes),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("No") }, Keyword::No),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Confluent") }, Keyword::Confluent),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Boolean") }, Keyword::Boolean),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Cross") }, Keyword::Cross),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Regex") }, Keyword::Regex),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Right") }, Keyword::Right),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Registry") }, Keyword::Registry),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Secrets") }, Keyword::Secrets),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Log") }, Keyword::Log),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Coalesce") }, Keyword::Coalesce),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Reset") }, Keyword::Reset),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Cardinality") }, Keyword::Cardinality),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Prepare") }, Keyword::Prepare),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Order") }, Keyword::Order),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Array") }, Keyword::Array),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Replica") }, Keyword::Replica),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Asc") }, Keyword::Asc),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Explain") }, Keyword::Explain),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Materialize") }, Keyword::Materialize),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Returning") }, Keyword::Returning),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Datums") }, Keyword::Datums),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Smallint") }, Keyword::Smallint),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Then") }, Keyword::Then),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Connections") }, Keyword::Connections),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Key") }, Keyword::Key),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Login") }, Keyword::Login),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Raise") }, Keyword::Raise),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Preceding") }, Keyword::Preceding),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("And") }, Keyword::And),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Minutes") }, Keyword::Minutes),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Nocreatecluster") }, Keyword::Nocreatecluster),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Day") }, Keyword::Day),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Managed") }, Keyword::Managed),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Varying") }, Keyword::Varying),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Check") }, Keyword::Check),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Sinks") }, Keyword::Sinks),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Nosuperuser") }, Keyword::Nosuperuser),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Create") }, Keyword::Create),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Inner") }, Keyword::Inner),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Broken") }, Keyword::Broken),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Connection") }, Keyword::Connection),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Token") }, Keyword::Token),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Years") }, Keyword::Years),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Databases") }, Keyword::Databases),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Show") }, Keyword::Show),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Transaction") }, Keyword::Transaction),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Compaction") }, Keyword::Compaction),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Trace") }, Keyword::Trace),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Chain") }, Keyword::Chain),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Acks") }, Keyword::Acks),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Cascade") }, Keyword::Cascade),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Month") }, Keyword::Month),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Idle") }, Keyword::Idle),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Values") }, Keyword::Values),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Begin") }, Keyword::Begin),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Escape") }, Keyword::Escape),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Nologin") }, Keyword::Nologin),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("If") }, Keyword::If),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Shard") }, Keyword::Shard),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Index") }, Keyword::Index),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Dec") }, Keyword::Dec),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Aws") }, Keyword::Aws),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Nocreaterole") }, Keyword::Nocreaterole),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Clusters") }, Keyword::Clusters),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("To") }, Keyword::To),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Restrict") }, Keyword::Restrict),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Element") }, Keyword::Element),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Certificate") }, Keyword::Certificate),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Load") }, Keyword::Load),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Storagectl") }, Keyword::Storagectl),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Plans") }, Keyword::Plans),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Tail") }, Keyword::Tail),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Trailing") }, Keyword::Trailing),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Between") }, Keyword::Between),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Delimiter") }, Keyword::Delimiter),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("In") }, Keyword::In),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("With") }, Keyword::With),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Users") }, Keyword::Users),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Bpchar") }, Keyword::Bpchar),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Header") }, Keyword::Header),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Unique") }, Keyword::Unique),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Zones") }, Keyword::Zones),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Following") }, Keyword::Following),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Exists") }, Keyword::Exists),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Inline") }, Keyword::Inline),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("For") }, Keyword::For),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Respect") }, Keyword::Respect),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Characteristics") }, Keyword::Characteristics),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Character") }, Keyword::Character),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Ssh") }, Keyword::Ssh),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Next") }, Keyword::Next),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Groups") }, Keyword::Groups),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Primary") }, Keyword::Primary),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Serializable") }, Keyword::Serializable),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Views") }, Keyword::Views),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Privileges") }, Keyword::Privileges),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Raw") }, Keyword::Raw),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Username") }, Keyword::Username),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("References") }, Keyword::References),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Alter") }, Keyword::Alter),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Owned") }, Keyword::Owned),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Local") }, Keyword::Local),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Access") }, Keyword::Access),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Usage") }, Keyword::Usage),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Greatest") }, Keyword::Greatest),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Availability") }, Keyword::Availability),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("False") }, Keyword::False),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Or") }, Keyword::Or),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Without") }, Keyword::Without),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("List") }, Keyword::List),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Computectl") }, Keyword::Computectl),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Cast") }, Keyword::Cast),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Seed") }, Keyword::Seed),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Quote") }, Keyword::Quote),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Ties") }, Keyword::Ties),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Strict") }, Keyword::Strict),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Desc") }, Keyword::Desc),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Constraint") }, Keyword::Constraint),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Text") }, Keyword::Text),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("End") }, Keyword::End),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Topic") }, Keyword::Topic),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("From") }, Keyword::From),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Mechanisms") }, Keyword::Mechanisms),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Nulls") }, Keyword::Nulls),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Url") }, Keyword::Url),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("First") }, Keyword::First),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Password") }, Keyword::Password),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Name") }, Keyword::Name),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Secret") }, Keyword::Secret),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Details") }, Keyword::Details),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Database") }, Keyword::Database),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("When") }, Keyword::When),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Isnull") }, Keyword::Isnull),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Auction") }, Keyword::Auction),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Marketing") }, Keyword::Marketing),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Select") }, Keyword::Select),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Columns") }, Keyword::Columns),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Metadata") }, Keyword::Metadata),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Endpoint") }, Keyword::Endpoint),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Bigint") }, Keyword::Bigint),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Any") }, Keyword::Any),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Repeatable") }, Keyword::Repeatable),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Bytes") }, Keyword::Bytes),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Warning") }, Keyword::Warning),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Ssl") }, Keyword::Ssl),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Tables") }, Keyword::Tables),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Over") }, Keyword::Over),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Leading") }, Keyword::Leading),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Map") }, Keyword::Map),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Time") }, Keyword::Time),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Include") }, Keyword::Include),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Merge") }, Keyword::Merge),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Inspect") }, Keyword::Inspect),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Subsource") }, Keyword::Subsource),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Subscribe") }, Keyword::Subscribe),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Temporary") }, Keyword::Temporary),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Except") }, Keyword::Except),
(unsafe { ::core::mem::transmute::<&'static str, &'static UncasedStr>("Noinherit") }, Keyword::Noinherit),
],
};