From 1db91503aabd67872b966d78a86c00247a86d934 Mon Sep 17 00:00:00 2001
From: Drew Davis <drew.davis@clickhouse.com>
Date: Mon, 8 Jun 2026 16:12:49 -0400
Subject: [PATCH] eliminate OpaqueStatement, parse everything

---
 .claude/settings.json                         |     8 +-
 src/ast.ts                                    |   688 +-
 src/explain.ts                                |   396 +-
 src/format.ts                                 |   512 +-
 src/grammar.pegjs                             |   520 +-
 src/parser.js                                 | 25541 +++++++++++-----
 src/transform-nodes.ts                        |     9 +
 ...es_and_system_tables.sql.expected.ast.json |    80 +-
 ...d_system_tables.sql.expected.formatted.sql |     4 +-
 ..._format_pretty_color.sql.expected.ast.json |     7 +-
 ...ary_table_management.sql.expected.ast.json |    11 +-
 ...12_show_tables_limit.sql.expected.ast.json |    55 +-
 ..._dictionaries_create.sql.expected.ast.json |    30 +-
 .../01033_quota_dcl.sql.expected.ast.json     |    12 +-
 ...op_database_mat_view.sql.expected.ast.json |    12 +-
 ...tabase_mat_view.sql.expected.formatted.sql |     2 +-
 ...073_grant_and_revoke.sql.expected.ast.json |   330 +-
 ...show_tables_not_like.sql.expected.ast.json |   134 +-
 ...1074_partial_revokes.sql.expected.ast.json |   246 +-
 ...allowed_client_hosts.sql.expected.ast.json |   348 +-
 ...ed_client_hosts.sql.expected.formatted.sql |     8 +-
 ...119_weird_user_names.sql.expected.ast.json |    32 +-
 ...eird_user_names.sql.expected.formatted.sql |     4 +-
 ...dl_cannot_add_column.sql.expected.ast.json |     7 +-
 ...52_cross_replication.sql.expected.ast.json |    16 +-
 ...ve_materialized_view.sql.expected.ast.json |    16 +-
 ...1_information_schema.sql.expected.ast.json |     8 +-
 ...transaction_counters.sql.expected.ast.json |    12 +-
 ...action_counters.sql.expected.formatted.sql |     6 +-
 ...tion_control_queries.sql.expected.ast.json |    16 +-
 ...control_queries.sql.expected.formatted.sql |     6 +-
 ...ate_or_replace_table.sql.expected.ast.json |     7 +-
 ...r_replace_table.sql.expected.formatted.sql |     2 +-
 ...1271_show_privileges.sql.expected.ast.json |     6 +-
 .../01292_create_user.sql.expected.ast.json   |   848 +-
 ...292_create_user.sql.expected.formatted.sql |     2 +-
 .../01293_create_role.sql.expected.ast.json   |   253 +-
 .../01293_show_settings.sql.expected.ast.json |    33 +-
 ...3_show_settings.sql.expected.formatted.sql |     2 +-
 ...ate_settings_profile.sql.expected.ast.json |   307 +-
 ...ettings_profile.sql.expected.formatted.sql |    22 +-
 ...95_create_row_policy.sql.expected.ast.json |   374 +-
 ...eate_row_policy.sql.expected.formatted.sql |    20 +-
 ..._in_current_database.sql.expected.ast.json |   247 +-
 ...urrent_database.sql.expected.formatted.sql |    24 +-
 .../01297_create_quota.sql.expected.ast.json  |   406 +-
 ...97_create_quota.sql.expected.formatted.sql |    16 +-
 .../01355_ilike.sql.expected.ast.json         |    35 +-
 ...1418_custom_settings.sql.expected.ast.json |    24 +-
 ..._show_databases_like.sql.expected.ast.json |    10 +-
 ..._databases_like.sql.expected.formatted.sql |     2 +-
 ..._mv_with_inner_table.sql.expected.ast.json |    24 +-
 ...ith_inner_table.sql.expected.formatted.sql |     6 +-
 ...ofile_while_assigned.sql.expected.ast.json |    19 +-
 ...702_system_query_log.sql.expected.ast.json |   216 +-
 ...ystem_query_log.sql.expected.formatted.sql |     2 +-
 ...9_grant_with_replace.sql.expected.ast.json |   359 +-
 ...nt_with_replace.sql.expected.formatted.sql |     4 +-
 ...ecovery_escaped_name.sql.expected.ast.json |    24 +-
 ...4_fp_seconds_profile.sql.expected.ast.json |    24 +-
 ...seconds_profile.sql.expected.formatted.sql |     4 +-
 ...implicit_transaction.sql.expected.ast.json |     8 +-
 ...che_eligible_queries.sql.expected.ast.json |    17 +-
 ...intact_when_mutation.sql.expected.ast.json |     8 +-
 .../02681_undrop_query.sql.expected.ast.json  |    60 +-
 ...81_undrop_query.sql.expected.formatted.sql |    16 +-
 .../02706_show_columns.sql.expected.ast.json  |   231 +-
 ...06_show_columns.sql.expected.formatted.sql |     4 +-
 .../02710_show_table.sql.expected.ast.json    |    18 +-
 .../02724_show_indexes.sql.expected.ast.json  |   165 +-
 ...24_show_indexes.sql.expected.formatted.sql |     4 +-
 ...lled_from_clickhouse.sql.expected.ast.json |    11 +-
 ...42_truncate_database.sql.expected.ast.json |    16 +-
 ...2867_create_user_ssh.sql.expected.ast.json |    44 +-
 ...create_user_ssh.sql.expected.formatted.sql |     8 +-
 ...able_without_keyword.sql.expected.ast.json |    34 +-
 ...show_databases_limit.sql.expected.ast.json |    12 +-
 ...5_show_setting_query.sql.expected.ast.json |    14 +-
 ...part_query_parameter.sql.expected.ast.json |    82 +-
 ...query_parameter.sql.expected.formatted.sql |     8 +-
 ...3141_wildcard_grants.sql.expected.ast.json |   150 +-
 ..._methods_show_create.sql.expected.ast.json |    12 +-
 ...ry_transaction_crash.sql.expected.ast.json |     8 +-
 ...286_backup_to_memory.sql.expected.ast.json |    48 +-
 ...03286_backup_to_null.sql.expected.ast.json |    34 +-
 .../03442_detach_view.sql.expected.ast.json   |    19 +-
 ..._parametric_grantees.sql.expected.ast.json |    12 +-
 ...th_broken_projection.sql.expected.ast.json |    35 +-
 ...oken_projection.sql.expected.formatted.sql |     2 +-
 ...em_grants_parameters.sql.expected.ast.json |   120 +-
 ...ants_parameters.sql.expected.formatted.sql |     4 +-
 ...3601_temporary_views.sql.expected.ast.json |    12 +-
 ..._excessive_backticks.sql.expected.ast.json |    12 +-
 ...4_queries_escaping_1.sql.expected.ast.json |    18 +-
 ...ries_escaping_1.sql.expected.formatted.sql |     2 +-
 ...4_queries_escaping_2.sql.expected.ast.json |    12 +-
 ...ries_escaping_2.sql.expected.formatted.sql |     2 +-
 ...ametrize_view_schema.sql.expected.ast.json |    22 +-
 ...ize_view_schema.sql.expected.formatted.sql |     4 +-
 ...ith_localhost_remote.sql.expected.ast.json |    58 +-
 ...ocalhost_remote.sql.expected.formatted.sql |     2 +-
 ...kup_keepermap_memory.sql.expected.ast.json |    34 +-
 ...eepermap_memory.sql.expected.formatted.sql |     4 +-
 ...0_backup_tar_archive.sql.expected.ast.json |    62 +-
 104 files changed, 24600 insertions(+), 9246 deletions(-)

diff --git a/.claude/settings.json b/.claude/settings.json
index b7ed75593..36df9282b 100644
--- a/.claude/settings.json
+++ b/.claude/settings.json
@@ -2,12 +2,8 @@
   "permissions": {
     "allow": [
       "Bash(npm test)",
-      "Bash(npm run generate:parser)",
-      "Bash(npm run build)",
-      "Bash(npm run typecheck)",
-      "Bash(npm run lint)",
-      "Bash(npm run explain:ch *)",
+      "Bash(npm run *)",
       "Bash(awk *)"
     ]
   }
-}
+}
\ No newline at end of file
diff --git a/src/ast.ts b/src/ast.ts
index 6f68ce2f2..b8375c2a1 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -1382,14 +1382,19 @@ export type RoleTarget =
 export type DefaultRoleClause = RoleTarget;
 
 /**
- * A SET TRANSACTION SNAPSHOT statement.
+ * A transaction control statement: `BEGIN [TRANSACTION]`, `COMMIT`, `ROLLBACK`,
+ * or `SET TRANSACTION SNAPSHOT n`.
  *
- * @example `SET TRANSACTION SNAPSHOT 1` → `{ kind: 'transactionControl', snapshot: '1' }`
+ * @example `BEGIN TRANSACTION` → `{ kind: 'transactionControl', action: 'begin' }`
+ * @example `COMMIT` → `{ kind: 'transactionControl', action: 'commit' }`
+ * @example `SET TRANSACTION SNAPSHOT 1` → `{ kind: 'transactionControl', action: 'snapshot', snapshot: '1' }`
  */
 export type TransactionControlStatement = {
   kind: 'transactionControl';
-  /** The snapshot number. */
-  snapshot: string;
+  /** Which transaction control action this statement performs. */
+  action: 'begin' | 'commit' | 'rollback' | 'snapshot';
+  /** The snapshot number (only present when `action` is `'snapshot'`). */
+  snapshot?: string;
 } & NodeMetadata;
 
 /**
@@ -1753,8 +1758,8 @@ export type CreateWorkloadStatement = {
 export type AuthenticationData = {
   /** Secret value (password, hash, realm, server name). */
   secret?: string;
-  /** Number of SSH keys (for ssh_key type). */
-  sshKeys?: number;
+  /** SSH public keys (for the `ssh_key` auth type): `KEY '<key>' TYPE '<type>'`. */
+  sshKeys?: { key: string; type: string }[];
 };
 
 /** `CREATE USER`. */
@@ -2045,13 +2050,21 @@ type AlterDelete = AlterCommandBase & {
 type AlterDropOrAttachPartition = AlterCommandBase & {
   commandType: 'DROP_PARTITION' | 'ATTACH_PARTITION';
   partition?: AlterPartitionExpr;
-  partName?: Literal;
+  partName?: Literal | QueryParam;
 };
 
-/** ALTER TABLE ... DROP DETACHED PARTITION expr */
+/** ALTER TABLE ... DROP DETACHED PARTITION expr (or DETACHED PART 'name') */
 type AlterDropDetachedPartition = AlterCommandBase & {
   commandType: 'DROP_DETACHED_PARTITION';
-  partition: AlterPartitionExpr;
+  partition?: AlterPartitionExpr;
+  partName?: Literal | QueryParam;
+};
+
+/** ALTER TABLE ... MODIFY REFRESH ... — refresh schedule for a refreshable materialized view */
+type AlterModifyRefresh = AlterCommandBase & {
+  commandType: 'MODIFY_REFRESH';
+  /** The refresh schedule text following the REFRESH keyword. */
+  refresh: string;
 };
 
 /** ALTER TABLE ... REPLACE PARTITION expr FROM table */
@@ -2180,6 +2193,7 @@ export type AlterCommand =
   | AlterResetSetting
   | AlterModifyQuery
   | AlterModifyComment
+  | AlterModifyRefresh
   | AlterApplyOrRewrite;
 
 /**
@@ -2305,6 +2319,325 @@ export type DropStatement = {
   format?: string;
 } & NodeMetadata;
 
+/**
+ * An UNDROP TABLE statement: restores a recently dropped table.
+ *
+ * @example `UNDROP TABLE t` → `{ kind: 'undrop', table: { kind: 'tableRef', table: 't' } }`
+ */
+export type UndropStatement = {
+  kind: 'undrop';
+  /** The table being restored. */
+  table: TableRef;
+  /** Whether IF NOT EXISTS was specified. */
+  ifNotExists?: boolean;
+  /** Optional UUID literal value (without quotes). */
+  uuid?: string;
+  /** Optional ON CLUSTER clause. */
+  onCluster?: string;
+  /** Optional FORMAT clause. */
+  format?: string;
+} & NodeMetadata;
+
+/**
+ * A BACKUP/RESTORE destination, e.g. `Disk('backups', 'b.tar')`, `Memory('b1')`, `Null`.
+ */
+export type BackupDestination = {
+  /** The destination engine/function name (`Disk`, `S3`, `Memory`, `Null`, ...). */
+  name: string;
+  /** Arguments inside parentheses; `undefined` when no parentheses were present. */
+  args?: Expression[];
+};
+
+/** A single element in a BACKUP/RESTORE target list. */
+export type BackupElement =
+  | {
+      kind: 'table' | 'dictionary' | 'view' | 'temporaryTable';
+      /** The table being backed up/restored. */
+      table: TableRef;
+      /** Optional `AS [db.]name` rename target. */
+      as?: TableRef;
+      /** Optional `PARTITION(S) ...` expressions. */
+      partitions?: Expression[];
+      /** Optional `EXCEPT COLUMNS (...)` column names. */
+      exceptColumns?: string[];
+    }
+  | { kind: 'database'; name: Identifier; as?: Identifier; exceptTables?: Identifier[] }
+  | { kind: 'function'; name: Identifier }
+  | { kind: 'namedCollection'; name: Identifier }
+  | { kind: 'all'; exceptDatabases?: Identifier[]; exceptTables?: TableRef[] };
+
+/**
+ * A BACKUP or RESTORE statement.
+ *
+ * @example `BACKUP TABLE t TO Disk('d', 'b.zip')` →
+ *   `{ kind: 'backup', operation: 'BACKUP', elements: [{ kind: 'table', table: ... }], destination: { name: 'Disk', args: [...] } }`
+ */
+export type BackupStatement = {
+  kind: 'backup';
+  /** Whether this is a BACKUP or a RESTORE. */
+  operation: 'BACKUP' | 'RESTORE';
+  /** The list of backup targets. */
+  elements: BackupElement[];
+  /** The TO (BACKUP) / FROM (RESTORE) destination. */
+  destination: BackupDestination;
+  /** Optional ON CLUSTER clause. */
+  onCluster?: string;
+  /** Optional SETTINGS clause. */
+  settings?: SettingItem[];
+  /** Optional SYNC / ASYNC modifier. */
+  wait?: 'SYNC' | 'ASYNC';
+  /** Optional FORMAT clause. */
+  format?: string;
+} & NodeMetadata;
+
+/** A `[NOT] LIKE|ILIKE 'pattern'` filter used by several SHOW statements. */
+export type ShowLike = {
+  /** Whether the `NOT` keyword was present. */
+  not?: boolean;
+  /** True for `ILIKE`, false/absent for `LIKE`. */
+  ilike?: boolean;
+  /** The pattern string (without quotes). */
+  pattern: string;
+};
+
+/** A name with an optional `ON table` (used by SHOW CREATE ROW POLICY). */
+export type ShowRowPolicyName = { names: string[]; table?: TableRef };
+
+/**
+ * What a {@link ShowStatement} displays. Discriminated by `type`.
+ */
+export type ShowTarget =
+  // SHOW [TEMPORARY] TABLES|DATABASES|DICTIONARIES [FROM db] [[NOT] LIKE|ILIKE p] [WHERE e] [LIMIT e] [SETTINGS ...]
+  | {
+      type: 'listing';
+      objectType: 'TABLES' | 'DATABASES' | 'DICTIONARIES';
+      temporary?: boolean;
+      from?: Identifier;
+      like?: ShowLike;
+      where?: Expression;
+      limit?: Expression;
+      settings?: SettingItem[];
+    }
+  // SHOW [CURRENT|ENABLED|CHANGED] CLUSTERS|ROLES|USERS|QUOTAS|POLICIES|PROFILES|COLLECTIONS|WARNINGS|SETTINGS
+  | {
+      type: 'accessEntities';
+      objectType:
+        | 'CLUSTERS'
+        | 'ROLES'
+        | 'USERS'
+        | 'QUOTAS'
+        | 'ROW POLICIES'
+        | 'SETTINGS PROFILES'
+        | 'NAMED COLLECTIONS'
+        | 'WARNINGS'
+        | 'SETTINGS';
+      modifier?: 'CURRENT' | 'ENABLED' | 'CHANGED';
+      like?: ShowLike;
+      limit?: Expression;
+    }
+  // SHOW CLUSTER name
+  | { type: 'cluster'; name: Identifier }
+  // SHOW [EXTENDED] [FULL] COLUMNS|FIELDS FROM table [FROM db] [[NOT] LIKE|ILIKE p] [WHERE e] [LIMIT e]
+  | {
+      type: 'columns';
+      keyword: 'COLUMNS' | 'FIELDS';
+      extended?: boolean;
+      full?: boolean;
+      table: TableRef;
+      from?: Identifier;
+      like?: ShowLike;
+      where?: Expression;
+      limit?: Expression;
+    }
+  // SHOW [EXTENDED] INDEX|INDEXES|INDICES|KEYS FROM table [FROM db] [WHERE e]
+  | {
+      type: 'indexes';
+      keyword: 'INDEX' | 'INDEXES' | 'INDICES' | 'KEYS';
+      extended?: boolean;
+      table: TableRef;
+      from?: Identifier;
+      where?: Expression;
+    }
+  // SHOW [SETTING] name
+  | { type: 'setting'; name: Identifier }
+  // Keyword-only forms with no arguments.
+  | { type: 'privileges' }
+  | { type: 'engines' }
+  | { type: 'merges' }
+  | { type: 'access' }
+  | { type: 'processlist'; full?: boolean }
+  // SHOW FUNCTIONS [[LIKE|ILIKE] p]
+  | { type: 'functions'; like?: ShowLike }
+  // SHOW GRANTS [FOR users] [WITH IMPLICIT] [FINAL]
+  | { type: 'grants'; for?: string[]; withImplicit?: boolean; final?: boolean }
+  // SHOW CREATE USER|ROLE|QUOTA|SETTINGS PROFILE|NAMED COLLECTION name {, name}
+  | {
+      type: 'createAccess';
+      entity: 'USER' | 'ROLE' | 'QUOTA' | 'SETTINGS PROFILE' | 'NAMED COLLECTION';
+      names: AccessControlName[];
+    }
+  // SHOW CREATE [ROW] POLICY name ON table {, ...}
+  | { type: 'createRowPolicy'; policies: ShowRowPolicyName[] }
+  // SHOW TABLE|VIEW name  (shorthand for SHOW CREATE TABLE/VIEW)
+  | { type: 'objectShorthand'; objectType: 'TABLE' | 'VIEW'; temporary?: boolean; table: TableRef }
+  // SHOW DATABASE name  (shorthand for SHOW CREATE DATABASE)
+  | { type: 'databaseShorthand'; database: Identifier };
+
+/**
+ * A SHOW statement.
+ *
+ * @example `SHOW TABLES FROM db` →
+ *   `{ kind: 'show', show: { type: 'listing', objectType: 'TABLES', from: 'db' } }`
+ */
+export type ShowStatement = {
+  kind: 'show';
+  /** The structured description of what is being shown. */
+  show: ShowTarget;
+  /** Optional trailing FORMAT clause. */
+  format?: string;
+} & NodeMetadata;
+
+/** A single privilege in a GRANT/REVOKE statement, e.g. `SELECT(col1, col2)`. */
+export type GrantPrivilege = {
+  /** The privilege name (may be multi-word, e.g. `CREATE TEMPORARY TABLE`). */
+  name: string;
+  /** Optional column list for column-level privileges. */
+  columns?: string[];
+};
+
+/**
+ * The `ON` target of a privilege grant.
+ *
+ * Parts may be `*` (wildcard) or wildcard-suffixed identifiers like `test*`.
+ *
+ * @example `db1.*` → `{ database: 'db1', table: '*' }`
+ * @example `*.*` → `{ database: '*', table: '*' }`
+ * @example `S3` → `{ table: 'S3' }`
+ */
+export type GrantTarget = {
+  /** Database part (absent for single-part targets). */
+  database?: string;
+  /** Table/object part. */
+  table: string;
+};
+
+/**
+ * One `privileges ON target` element of a privilege grant.
+ *
+ * A single GRANT may grant several privileges on several targets, e.g.
+ * `GRANT SELECT ON a.*, INSERT ON b.* TO u`.
+ */
+export type GrantElement = {
+  /** Privileges granted/revoked on this target. */
+  privileges: GrantPrivilege[];
+  /** The `ON` target. */
+  target: GrantTarget;
+};
+
+/**
+ * A GRANT or REVOKE statement.
+ *
+ * Either `elements` (privilege grant) or `roles` (role grant) is set.
+ *
+ * @example `GRANT SELECT ON db.* TO u` →
+ *   `{ kind: 'grant', operation: 'GRANT', elements: [{ privileges: [{ name: 'SELECT' }], target: { database: 'db', table: '*' } }], grantees: ['u'] }`
+ */
+export type GrantStatement = {
+  kind: 'grant';
+  /** Whether this grants or revokes. */
+  operation: 'GRANT' | 'REVOKE';
+  /** Privilege-on-target elements (privilege grant). */
+  elements?: GrantElement[];
+  /** Role names being granted/revoked (role grant). */
+  roles?: string[];
+  /** The users/roles receiving (GRANT) or losing (REVOKE) the grant. */
+  grantees: string[];
+  /** Optional ON CLUSTER clause. */
+  onCluster?: string;
+  /** REVOKE `GRANT OPTION FOR` / `ADMIN OPTION FOR` prefix. */
+  optionFor?: 'GRANT' | 'ADMIN';
+  /** Trailing `WITH ... OPTION` modifiers. */
+  withOptions?: ('GRANT' | 'ADMIN' | 'REPLACE')[];
+} & NodeMetadata;
+
+/** A single clause of an ALTER USER statement. */
+export type AlterUserClause =
+  | { kind: 'rename'; to: AccessControlName }
+  | { kind: 'identified'; auth: AuthenticationData[] }
+  | { kind: 'notIdentified' }
+  | { kind: 'host'; mode?: 'ADD' | 'DROP'; hosts: HostItem[] }
+  | { kind: 'settings'; settings: AccessControlSettingsItem[] | 'NONE' }
+  | { kind: 'defaultRole'; roles: RoleTarget }
+  | { kind: 'defaultDatabase'; database: string }
+  | { kind: 'grantees'; grantees: RoleTarget }
+  | { kind: 'validUntil'; value: string };
+
+/** `ALTER USER`. */
+export type AlterUserStatement = {
+  kind: 'alterUser';
+  names: AccessControlName[];
+  ifExists?: boolean;
+  onCluster?: string;
+  /** Ordered clauses applied to the user(s). */
+  clauses: AlterUserClause[];
+} & NodeMetadata;
+
+/** `ALTER ROLE`. */
+export type AlterRoleStatement = {
+  kind: 'alterRole';
+  names: AccessControlName[];
+  ifExists?: boolean;
+  onCluster?: string;
+  renameTo?: AccessControlName;
+  settings?: AccessControlSettingsItem[] | 'NONE';
+} & NodeMetadata;
+
+/** `ALTER QUOTA`. */
+export type AlterQuotaStatement = {
+  kind: 'alterQuota';
+  names: string[];
+  ifExists?: boolean;
+  onCluster?: string;
+  renameTo?: string;
+  keyed?: { notKeyed: true } | { keys: string[] };
+  intervals?: {
+    randomized?: boolean;
+    duration: string;
+    unit: string;
+    trackingOnly?: boolean;
+    noLimits?: boolean;
+    limits?: { name: string; value: Expression }[];
+  }[];
+  to?: RoleTarget;
+} & NodeMetadata;
+
+/** `ALTER ROW POLICY` (or `ALTER POLICY`). */
+export type AlterRowPolicyStatement = {
+  kind: 'alterRowPolicy';
+  hasRowKeyword?: boolean;
+  targets: { names: string[]; table: TableRef }[];
+  ifExists?: boolean;
+  onCluster?: string;
+  renameTo?: string;
+  /** Whether a `FOR SELECT` clause was present. */
+  forSelect?: boolean;
+  using?: Expression;
+  restrictive?: 'RESTRICTIVE' | 'PERMISSIVE';
+  to?: RoleTarget;
+} & NodeMetadata;
+
+/** `ALTER SETTINGS PROFILE` (or `ALTER PROFILE`). */
+export type AlterSettingsProfileStatement = {
+  kind: 'alterSettingsProfile';
+  hasSettingsKeyword?: boolean;
+  names: string[];
+  ifExists?: boolean;
+  onCluster?: string;
+  renameTo?: string;
+  settings?: AccessControlSettingsItem[] | 'NONE';
+  to?: RoleTarget;
+} & NodeMetadata;
+
 /**
  * OPTIMIZE TABLE: forces merges/deduplication.
  *
@@ -2519,6 +2852,15 @@ export type Statement =
   | InsertStatement
   | TruncateStatement
   | DropStatement
+  | UndropStatement
+  | BackupStatement
+  | GrantStatement
+  | ShowStatement
+  | AlterUserStatement
+  | AlterRoleStatement
+  | AlterQuotaStatement
+  | AlterRowPolicyStatement
+  | AlterSettingsProfileStatement
   | OptimizeStatement
   | DescribeStatement
   | ShowCreateStatement
@@ -2601,6 +2943,15 @@ export interface ASTNodeKindMap {
   insert: InsertStatement;
   truncate: TruncateStatement;
   drop: DropStatement;
+  undrop: UndropStatement;
+  backup: BackupStatement;
+  grant: GrantStatement;
+  show: ShowStatement;
+  alterUser: AlterUserStatement;
+  alterRole: AlterRoleStatement;
+  alterQuota: AlterQuotaStatement;
+  alterRowPolicy: AlterRowPolicyStatement;
+  alterSettingsProfile: AlterSettingsProfileStatement;
   optimize: OptimizeStatement;
   describe: DescribeStatement;
   showCreate: ShowCreateStatement;
@@ -2839,7 +3190,8 @@ export const TransactionControlStatementSchema: z.ZodType<TransactionControlStat
   () =>
     z.object({
       kind: z.literal('transactionControl'),
-      snapshot: z.string(),
+      action: z.enum(['begin', 'commit', 'rollback', 'snapshot']),
+      snapshot: z.string().optional(),
       ...ExprMetadataFields,
     }),
 );
@@ -3168,7 +3520,7 @@ export const CreateUserStatementSchema: z.ZodType<CreateUserStatement> = z.lazy(
       .array(
         z.object({
           secret: z.string().optional(),
-          sshKeys: z.number().optional(),
+          sshKeys: z.array(z.object({ key: z.string(), type: z.string() })).optional(),
         }),
       )
       .optional(),
@@ -3445,18 +3797,24 @@ export const AlterCommandSchema: z.ZodType<AlterCommand> = z.lazy(() =>
       ...AlterCommandBaseFields,
       commandType: z.literal('DROP_PARTITION'),
       partition: AlterPartitionExprSchema.optional(),
-      partName: LiteralSchema.optional(),
+      partName: z.union([LiteralSchema, QueryParamSchema]).optional(),
     }),
     z.object({
       ...AlterCommandBaseFields,
       commandType: z.literal('ATTACH_PARTITION'),
       partition: AlterPartitionExprSchema.optional(),
-      partName: LiteralSchema.optional(),
+      partName: z.union([LiteralSchema, QueryParamSchema]).optional(),
     }),
     z.object({
       ...AlterCommandBaseFields,
       commandType: z.literal('DROP_DETACHED_PARTITION'),
-      partition: AlterPartitionExprSchema,
+      partition: AlterPartitionExprSchema.optional(),
+      partName: z.union([LiteralSchema, QueryParamSchema]).optional(),
+    }),
+    z.object({
+      ...AlterCommandBaseFields,
+      commandType: z.literal('MODIFY_REFRESH'),
+      refresh: z.string(),
     }),
     z.object({
       ...AlterCommandBaseFields,
@@ -3635,6 +3993,299 @@ export const DropStatementSchema: z.ZodType<DropStatement> = z.lazy(() =>
   }),
 );
 
+/** Zod schema for {@link UndropStatement}. */
+export const UndropStatementSchema: z.ZodType<UndropStatement> = z.lazy(() =>
+  z.object({
+    kind: z.literal('undrop'),
+    table: TableRefSchema,
+    ifNotExists: z.boolean().optional(),
+    uuid: z.string().optional(),
+    onCluster: z.string().optional(),
+    format: z.string().optional(),
+    ...ExprMetadataFields,
+  }),
+);
+
+/** Zod schema for {@link BackupDestination}. */
+export const BackupDestinationSchema: z.ZodType<BackupDestination> = z.lazy(() =>
+  z.object({
+    name: z.string(),
+    args: z.array(ExpressionSchema).optional(),
+  }),
+);
+
+/** Zod schema for {@link BackupElement}. */
+export const BackupElementSchema: z.ZodType<BackupElement> = z.lazy(() =>
+  z.union([
+    z.object({
+      kind: z.enum(['table', 'dictionary', 'view', 'temporaryTable']),
+      table: TableRefSchema,
+      as: TableRefSchema.optional(),
+      partitions: z.array(ExpressionSchema).optional(),
+      exceptColumns: z.array(z.string()).optional(),
+    }),
+    z.object({
+      kind: z.literal('database'),
+      name: IdentifierSchema,
+      as: IdentifierSchema.optional(),
+      exceptTables: z.array(IdentifierSchema).optional(),
+    }),
+    z.object({ kind: z.literal('function'), name: IdentifierSchema }),
+    z.object({ kind: z.literal('namedCollection'), name: IdentifierSchema }),
+    z.object({
+      kind: z.literal('all'),
+      exceptDatabases: z.array(IdentifierSchema).optional(),
+      exceptTables: z.array(TableRefSchema).optional(),
+    }),
+  ]),
+);
+
+/** Zod schema for {@link BackupStatement}. */
+export const BackupStatementSchema: z.ZodType<BackupStatement> = z.lazy(() =>
+  z.object({
+    kind: z.literal('backup'),
+    operation: z.enum(['BACKUP', 'RESTORE']),
+    elements: z.array(BackupElementSchema),
+    destination: BackupDestinationSchema,
+    onCluster: z.string().optional(),
+    settings: z.array(SettingItemSchema).optional(),
+    wait: z.enum(['SYNC', 'ASYNC']).optional(),
+    format: z.string().optional(),
+    ...ExprMetadataFields,
+  }),
+);
+
+/** Zod schema for {@link GrantStatement}. */
+export const GrantStatementSchema: z.ZodType<GrantStatement> = z.lazy(() =>
+  z.object({
+    kind: z.literal('grant'),
+    operation: z.enum(['GRANT', 'REVOKE']),
+    elements: z
+      .array(
+        z.object({
+          privileges: z.array(
+            z.object({ name: z.string(), columns: z.array(z.string()).optional() }),
+          ),
+          target: z.object({ database: z.string().optional(), table: z.string() }),
+        }),
+      )
+      .optional(),
+    roles: z.array(z.string()).optional(),
+    grantees: z.array(z.string()),
+    onCluster: z.string().optional(),
+    optionFor: z.enum(['GRANT', 'ADMIN']).optional(),
+    withOptions: z.array(z.enum(['GRANT', 'ADMIN', 'REPLACE'])).optional(),
+    ...ExprMetadataFields,
+  }),
+);
+
+const ShowLikeSchema: z.ZodType<ShowLike> = z.object({
+  not: z.boolean().optional(),
+  ilike: z.boolean().optional(),
+  pattern: z.string(),
+});
+
+/** Zod schema for {@link ShowStatement}. */
+export const ShowStatementSchema: z.ZodType<ShowStatement> = z.lazy(() =>
+  z.object({
+    kind: z.literal('show'),
+    show: z.union([
+      z.object({
+        type: z.literal('listing'),
+        objectType: z.enum(['TABLES', 'DATABASES', 'DICTIONARIES']),
+        temporary: z.boolean().optional(),
+        from: IdentifierSchema.optional(),
+        like: ShowLikeSchema.optional(),
+        where: ExpressionSchema.optional(),
+        limit: ExpressionSchema.optional(),
+        settings: z.array(SettingItemSchema).optional(),
+      }),
+      z.object({
+        type: z.literal('accessEntities'),
+        objectType: z.enum([
+          'CLUSTERS',
+          'ROLES',
+          'USERS',
+          'QUOTAS',
+          'ROW POLICIES',
+          'SETTINGS PROFILES',
+          'NAMED COLLECTIONS',
+          'WARNINGS',
+          'SETTINGS',
+        ]),
+        modifier: z.enum(['CURRENT', 'ENABLED', 'CHANGED']).optional(),
+        like: ShowLikeSchema.optional(),
+        limit: ExpressionSchema.optional(),
+      }),
+      z.object({ type: z.literal('cluster'), name: IdentifierSchema }),
+      z.object({
+        type: z.literal('columns'),
+        keyword: z.enum(['COLUMNS', 'FIELDS']),
+        extended: z.boolean().optional(),
+        full: z.boolean().optional(),
+        table: TableRefSchema,
+        from: IdentifierSchema.optional(),
+        like: ShowLikeSchema.optional(),
+        where: ExpressionSchema.optional(),
+        limit: ExpressionSchema.optional(),
+      }),
+      z.object({
+        type: z.literal('indexes'),
+        keyword: z.enum(['INDEX', 'INDEXES', 'INDICES', 'KEYS']),
+        extended: z.boolean().optional(),
+        table: TableRefSchema,
+        from: IdentifierSchema.optional(),
+        where: ExpressionSchema.optional(),
+      }),
+      z.object({ type: z.literal('setting'), name: IdentifierSchema }),
+      z.object({ type: z.literal('privileges') }),
+      z.object({ type: z.literal('engines') }),
+      z.object({ type: z.literal('merges') }),
+      z.object({ type: z.literal('access') }),
+      z.object({ type: z.literal('processlist'), full: z.boolean().optional() }),
+      z.object({ type: z.literal('functions'), like: ShowLikeSchema.optional() }),
+      z.object({
+        type: z.literal('grants'),
+        for: z.array(z.string()).optional(),
+        withImplicit: z.boolean().optional(),
+        final: z.boolean().optional(),
+      }),
+      z.object({
+        type: z.literal('createAccess'),
+        entity: z.enum(['USER', 'ROLE', 'QUOTA', 'SETTINGS PROFILE', 'NAMED COLLECTION']),
+        names: z.array(AccessControlNameSchema),
+      }),
+      z.object({
+        type: z.literal('createRowPolicy'),
+        policies: z.array(
+          z.object({ names: z.array(z.string()), table: TableRefSchema.optional() }),
+        ),
+      }),
+      z.object({
+        type: z.literal('objectShorthand'),
+        objectType: z.enum(['TABLE', 'VIEW']),
+        temporary: z.boolean().optional(),
+        table: TableRefSchema,
+      }),
+      z.object({ type: z.literal('databaseShorthand'), database: IdentifierSchema }),
+    ]),
+    format: z.string().optional(),
+    ...ExprMetadataFields,
+  }),
+);
+
+const AuthDataArraySchema = z.array(
+  z.object({
+    secret: z.string().optional(),
+    sshKeys: z.array(z.object({ key: z.string(), type: z.string() })).optional(),
+  }),
+);
+
+/** Zod schema for {@link AlterUserStatement}. */
+export const AlterUserStatementSchema: z.ZodType<AlterUserStatement> = z.lazy(() =>
+  z.object({
+    kind: z.literal('alterUser'),
+    names: z.array(AccessControlNameSchema),
+    ifExists: z.boolean().optional(),
+    onCluster: z.string().optional(),
+    clauses: z.array(
+      z.union([
+        z.object({ kind: z.literal('rename'), to: AccessControlNameSchema }),
+        z.object({ kind: z.literal('identified'), auth: AuthDataArraySchema }),
+        z.object({ kind: z.literal('notIdentified') }),
+        z.object({
+          kind: z.literal('host'),
+          mode: z.enum(['ADD', 'DROP']).optional(),
+          hosts: z.array(HostItemSchema),
+        }),
+        z.object({
+          kind: z.literal('settings'),
+          settings: z.union([z.array(AccessControlSettingsItemSchema), z.literal('NONE' as const)]),
+        }),
+        z.object({ kind: z.literal('defaultRole'), roles: RoleTargetSchema }),
+        z.object({ kind: z.literal('defaultDatabase'), database: z.string() }),
+        z.object({ kind: z.literal('grantees'), grantees: RoleTargetSchema }),
+        z.object({ kind: z.literal('validUntil'), value: z.string() }),
+      ]),
+    ),
+    ...ExprMetadataFields,
+  }),
+);
+
+/** Zod schema for {@link AlterRoleStatement}. */
+export const AlterRoleStatementSchema: z.ZodType<AlterRoleStatement> = z.lazy(() =>
+  z.object({
+    kind: z.literal('alterRole'),
+    names: z.array(AccessControlNameSchema),
+    ifExists: z.boolean().optional(),
+    onCluster: z.string().optional(),
+    renameTo: AccessControlNameSchema.optional(),
+    settings: AccessControlSettingsField,
+    ...ExprMetadataFields,
+  }),
+);
+
+/** Zod schema for {@link AlterQuotaStatement}. */
+export const AlterQuotaStatementSchema: z.ZodType<AlterQuotaStatement> = z.lazy(() =>
+  z.object({
+    kind: z.literal('alterQuota'),
+    names: z.array(z.string()),
+    ifExists: z.boolean().optional(),
+    onCluster: z.string().optional(),
+    renameTo: z.string().optional(),
+    keyed: z
+      .union([z.object({ notKeyed: z.literal(true) }), z.object({ keys: z.array(z.string()) })])
+      .optional(),
+    intervals: z
+      .array(
+        z.object({
+          randomized: z.boolean().optional(),
+          duration: z.string(),
+          unit: z.string(),
+          trackingOnly: z.boolean().optional(),
+          noLimits: z.boolean().optional(),
+          limits: z.array(z.object({ name: z.string(), value: ExpressionSchema })).optional(),
+        }),
+      )
+      .optional(),
+    to: RoleTargetSchema.optional(),
+    ...ExprMetadataFields,
+  }),
+);
+
+/** Zod schema for {@link AlterRowPolicyStatement}. */
+export const AlterRowPolicyStatementSchema: z.ZodType<AlterRowPolicyStatement> = z.lazy(() =>
+  z.object({
+    kind: z.literal('alterRowPolicy'),
+    hasRowKeyword: z.boolean().optional(),
+    targets: z.array(z.object({ names: z.array(z.string()), table: TableRefSchema })),
+    ifExists: z.boolean().optional(),
+    onCluster: z.string().optional(),
+    renameTo: z.string().optional(),
+    forSelect: z.boolean().optional(),
+    using: ExpressionSchema.optional(),
+    restrictive: z.enum(['RESTRICTIVE', 'PERMISSIVE']).optional(),
+    to: RoleTargetSchema.optional(),
+    ...ExprMetadataFields,
+  }),
+);
+
+/** Zod schema for {@link AlterSettingsProfileStatement}. */
+export const AlterSettingsProfileStatementSchema: z.ZodType<AlterSettingsProfileStatement> = z.lazy(
+  () =>
+    z.object({
+      kind: z.literal('alterSettingsProfile'),
+      hasSettingsKeyword: z.boolean().optional(),
+      names: z.array(z.string()),
+      ifExists: z.boolean().optional(),
+      onCluster: z.string().optional(),
+      renameTo: z.string().optional(),
+      settings: AccessControlSettingsField,
+      to: RoleTargetSchema.optional(),
+      ...ExprMetadataFields,
+    }),
+);
+
 /** Zod schema for {@link OptimizeStatement}. */
 export const OptimizeStatementSchema: z.ZodType<OptimizeStatement> = z.lazy(() =>
   z.object({
@@ -3842,6 +4493,15 @@ export const StatementSchema: z.ZodType<Statement> = z.lazy(() =>
     InsertStatementSchema,
     TruncateStatementSchema,
     DropStatementSchema,
+    UndropStatementSchema,
+    BackupStatementSchema,
+    GrantStatementSchema,
+    ShowStatementSchema,
+    AlterUserStatementSchema,
+    AlterRoleStatementSchema,
+    AlterQuotaStatementSchema,
+    AlterRowPolicyStatementSchema,
+    AlterSettingsProfileStatementSchema,
     OptimizeStatementSchema,
     DescribeStatementSchema,
     ShowCreateStatementSchema,
diff --git a/src/explain.ts b/src/explain.ts
index a66cee6f5..afbb8a9d1 100644
--- a/src/explain.ts
+++ b/src/explain.ts
@@ -2,7 +2,15 @@ import {
   AlterStatement,
   AlterCommand,
   AlterPartitionExpr,
+  AuthenticationData,
   BinaryExpr,
+  CodecItem,
+  DataType,
+  DataTypeArg,
+  Identifier,
+  IndexType,
+  Literal,
+  ShowStatement,
   CTE,
   ColumnDef,
   ColumnTransformer,
@@ -63,7 +71,7 @@ function n(label: string, children: ExplainNode[] = []): ExplainNode {
 }
 
 // Canonical string rendering for an Identifier (plain name or query-param).
-function id(x: import('./ast').Identifier): string {
+function id(x: Identifier): string {
   return typeof x === 'string' ? x : `{${x.name}:${x.type}}`;
 }
 
@@ -1152,7 +1160,7 @@ function viewExplainNode(stmt: ExplainStatement, aliasStr: string): ExplainNode
 // ── CREATE TABLE explain helpers ──────────────────────────────────────────────
 
 // Convert a structured DataType to an EXPLAIN node tree
-function dataTypeToExplainNode(dt: import('./ast').DataType): ExplainNode {
+function dataTypeToExplainNode(dt: DataType): ExplainNode {
   const baseName = dt.name;
 
   // Enum types with parsed values
@@ -1246,7 +1254,7 @@ function dataTypeToExplainNode(dt: import('./ast').DataType): ExplainNode {
 
 // Convert a single DataTypeArg to an EXPLAIN node
 function dataTypeArgToExplainNode(
-  arg: import('./ast').DataTypeArg,
+  arg: DataTypeArg,
   parentName: string,
   index: number,
 ): ExplainNode {
@@ -1286,7 +1294,7 @@ function dataTypeArgToExplainNode(
 }
 
 // Convert a JSON type argument to an ASTObjectTypeArgument explain node
-function jsonTypeArgToExplainNode(arg: import('./ast').DataTypeArg): ExplainNode {
+function jsonTypeArgToExplainNode(arg: DataTypeArg): ExplainNode {
   switch (arg.kind) {
     case 'namedField':
       // JSON(a String) → ASTObjectTypeArgument / ObjectTypedPath a / DataType String
@@ -1322,7 +1330,7 @@ function jsonTypeArgToExplainNode(arg: import('./ast').DataTypeArg): ExplainNode
 }
 
 // Convert structured CodecItem[] to EXPLAIN nodes
-function codecToExplainNodes(items: import('./ast').CodecItem[]): ExplainNode {
+function codecToExplainNodes(items: CodecItem[]): ExplainNode {
   const children = items.map((item) => {
     if (item.args !== undefined && item.args.length > 0) {
       return n(`Function ${item.name}`, [n('ExpressionList', item.args.map(exprNode))]);
@@ -1336,7 +1344,7 @@ function codecToExplainNodes(items: import('./ast').CodecItem[]): ExplainNode {
 }
 
 // Convert structured IndexType to EXPLAIN node
-function indexTypeToExplainNode(it: import('./ast').IndexType): ExplainNode {
+function indexTypeToExplainNode(it: IndexType): ExplainNode {
   if (it.args !== undefined && it.args.length > 0) {
     return n(`Function ${it.name}`, [n('ExpressionList', it.args.map(exprNode))]);
   }
@@ -1605,16 +1613,14 @@ function createDictionaryQueryNode(stmt: CreateDictionaryStatement): ExplainNode
       const pairNodes = dd.source.pairs.map((p) => {
         if (Array.isArray(p.value)) {
           // Structure pairs: render type as Identifier (simple) or Function (parameterized)
-          const structPairs = p.value.map(
-            (sp: { name: string; type: import('./ast').DataType }) => {
-              const dt = sp.type;
-              if (dt.args && dt.args.length > 0) {
-                const argNodes = dt.args.map((a, i) => dataTypeArgToExplainNode(a, dt.name, i));
-                return n('pair', [n(`Function ${dt.name}`, [n('ExpressionList', argNodes)])]);
-              }
-              return n('pair', [n(`Identifier ${dt.name}`)]);
-            },
-          );
+          const structPairs = p.value.map((sp: { name: string; type: DataType }) => {
+            const dt = sp.type;
+            if (dt.args && dt.args.length > 0) {
+              const argNodes = dt.args.map((a, i) => dataTypeArgToExplainNode(a, dt.name, i));
+              return n('pair', [n(`Function ${dt.name}`, [n('ExpressionList', argNodes)])]);
+            }
+            return n('pair', [n(`Identifier ${dt.name}`)]);
+          });
           return n('pair', [n('ExpressionList', structPairs)]);
         }
         return n('pair', [exprNode(p.value)]);
@@ -2174,7 +2180,7 @@ function partitionNode(part: AlterPartitionExpr): ExplainNode {
     if (part.id.kind === 'queryParam') {
       return n('Partition_ID', [exprNode(part.id)]);
     }
-    const lit = part.id as import('./ast').Literal;
+    const lit = part.id as Literal;
     const label = `Partition_ID Literal_'${escapeStringValue(lit.value)}'`;
     return n(label, [n(`Literal '${escapeStringValue(lit.value)}'`)]);
   }
@@ -2380,14 +2386,18 @@ function alterCommandNode(cmd: AlterCommand): ExplainNode {
 
     case 'DROP_PARTITION':
     case 'ATTACH_PARTITION':
+    case 'DROP_DETACHED_PARTITION':
       if (cmd.partName) {
-        // DETACH/DROP PART 'name' → direct Literal child
-        children.push(n(`Literal '${escapeStringValue(cmd.partName.value)}'`));
+        // DETACH/DROP PART 'name' → direct Literal child (query-param parts are query-param queries)
+        if (cmd.partName.kind === 'literal') {
+          children.push(n(`Literal '${escapeStringValue(cmd.partName.value)}'`));
+        } else {
+          children.push(exprNode(cmd.partName));
+        }
       } else if (cmd.partition) {
         children.push(partitionNode(cmd.partition));
       }
       break;
-    case 'DROP_DETACHED_PARTITION':
     case 'REPLACE_PARTITION':
     case 'MOVE_PARTITION':
     case 'FETCH_PARTITION':
@@ -2491,6 +2501,82 @@ function alterQueryNode(stmt: AlterStatement): ExplainNode {
   return n(label, children);
 }
 
+// Build the explain node for a SHOW statement.
+function showQueryNode(stmt: ShowStatement): ExplainNode {
+  const s = stmt.show;
+  const formatChild = (): ExplainNode[] => (stmt.format ? [n(`Identifier ${stmt.format}`)] : []);
+  switch (s.type) {
+    case 'listing': {
+      const children: ExplainNode[] = [];
+      if (s.from !== undefined) children.push(n(`Identifier ${id(s.from)}`));
+      if (s.settings && s.settings.length > 0) children.push(n('Set'));
+      children.push(...formatChild());
+      return n('ShowTables', children);
+    }
+    case 'accessEntities':
+    case 'cluster':
+      return n('ShowTables');
+    case 'columns':
+    case 'indexes':
+      return n('ShowColumns');
+    case 'setting':
+      return n('ShowSetting');
+    case 'privileges':
+      return n('ShowPrivilegesQuery');
+    case 'engines':
+      return n('ShowEngines');
+    case 'merges':
+      return n('ShowMerges');
+    case 'access':
+      return n('ShowAccessQuery');
+    case 'processlist':
+      return n('ShowProcesslist');
+    case 'functions':
+      return n('ShowFunctions');
+    case 'grants':
+      return n('ShowGrantsQuery', formatChild());
+    case 'createAccess': {
+      const hasFormat = stmt.format !== undefined;
+      const isMulti = s.names.length > 1;
+      const labels: Record<string, [string, string]> = {
+        USER: ['SHOW CREATE USER query', 'SHOW CREATE USERS query'],
+        ROLE: ['SHOW CREATE ROLE query', 'SHOW CREATE ROLES query'],
+        QUOTA: ['SHOW CREATE QUOTA query', 'SHOW CREATE QUOTAS query'],
+        'SETTINGS PROFILE': [
+          'SHOW CREATE SETTINGS PROFILE query',
+          'SHOW CREATE SETTINGS PROFILES query',
+        ],
+        'NAMED COLLECTION': ['ShowCreateNamedCollectionQuery', 'ShowCreateNamedCollectionQuery'],
+      };
+      const pair = labels[s.entity];
+      const usePlural = isMulti && !hasFormat;
+      return n(pair[usePlural ? 1 : 0], formatChild());
+    }
+    case 'createRowPolicy': {
+      const hasFormat = stmt.format !== undefined;
+      const label = hasFormat ? 'SHOW CREATE ROW POLICIES query' : 'SHOW CREATE ROW POLICY query';
+      return n(label, formatChild());
+    }
+    case 'objectShorthand': {
+      const t = s.table;
+      const prefix = s.objectType === 'VIEW' ? 'ShowCreateViewQuery' : 'ShowCreateTableQuery';
+      const children: ExplainNode[] = [];
+      if (t.database) children.push(n(`Identifier ${id(t.database)}`));
+      children.push(n(`Identifier ${id(t.table)}`));
+      children.push(...formatChild());
+      const label = t.database
+        ? `${prefix} ${id(t.database)} ${id(t.table)}`
+        : `${prefix}  ${id(t.table)}`;
+      return n(label, children);
+    }
+    case 'databaseShorthand': {
+      const children: ExplainNode[] = [n(`Identifier ${id(s.database)}`)];
+      children.push(...formatChild());
+      return n(`ShowCreateDatabaseQuery ${id(s.database)} `, children);
+    }
+  }
+}
+
 // Build the top-level SelectWithUnionQuery node for a statement (SelectStatement or UnionStatement)
 function stmtNode(stmt: Statement): ExplainNode {
   if (stmt.kind === 'parallelWith') return parallelWithQueryNode(stmt);
@@ -2502,40 +2588,11 @@ function stmtNode(stmt: Statement): ExplainNode {
     return n('Set');
   }
   if (stmt.kind === 'system') {
-    // Opaque ALTER statements for access control objects (ALTER USER, ALTER ROLE, etc.)
-    if (/^ALTER\s/i.test(stmt.body)) {
-      const alterAliases: Record<string, string> = {
-        USER: 'CreateUserQuery',
-        ROLE: 'CreateRoleQuery',
-        'ROW POLICY': 'CREATE ROW POLICY or ALTER ROW POLICY query',
-        POLICY: 'CREATE ROW POLICY or ALTER ROW POLICY query',
-        'SETTINGS PROFILE': 'CreateSettingsProfileQuery',
-        PROFILE: 'CreateSettingsProfileQuery',
-        QUOTA: 'CreateQuotaQuery',
-        'NAMED COLLECTION': 'AlterNamedCollectionQuery',
-      };
-      const m = stmt.body.match(
-        /^ALTER\s+(USER|ROLE|ROW\s+POLICY|POLICY|SETTINGS\s+PROFILE|PROFILE|QUOTA|NAMED\s+COLLECTION)\b/i,
-      );
-      if (m) {
-        const key = m[1].toUpperCase().replace(/\s+/g, ' ');
-        const label = alterAliases[key] || 'SYSTEM query';
-        // For ALTER USER, extract auth data
-        if (key === 'USER') {
-          const authByMatch = stmt.body.match(/IDENTIFIED\s+(?:WITH\s+\w+\s+)?BY\s+'([^']*)'/i);
-          if (authByMatch) {
-            return n(label, [n('AuthenticationData', [n(`Literal '${authByMatch[1]}'`)])]);
-          }
-          // NOT IDENTIFIED or IDENTIFIED WITH <type> (no password)
-          if (/(?:NOT\s+)?IDENTIFIED/i.test(stmt.body) && !/RENAME/i.test(stmt.body)) {
-            return n(label, [n('AuthenticationData')]);
-          }
-        }
-        return n(label);
-      }
-      return n('SYSTEM query');
-    }
-    // Opaque DROP statements produce specific labels based on the DROP target type
+    // The `system` kind is produced by SYSTEM statements and by the DROP fallback
+    // for access-control objects (DROP USER, DROP ROLE, etc.) that are not yet
+    // structurally parsed.
+    //
+    // DROP fallback statements produce specific labels based on the DROP target type.
     if (/^DROP\s/i.test(stmt.body)) {
       const dropAliases: Record<string, string> = {
         USER: 'DROP USER query',
@@ -2558,131 +2615,6 @@ function stmtNode(stmt: Statement): ExplainNode {
       }
       return n('SYSTEM query');
     }
-    // SHOW variants
-    if (/^SHOW\s/i.test(stmt.body)) {
-      // SHOW CREATE USER/ROLE/QUOTA/etc. → "<DDL> QUOTA query" labels
-      const showCreateACMatch = stmt.body.match(
-        /^SHOW\s+CREATE\s+(USERS|USER|ROLES|ROLE|QUOTAS|QUOTA|ROW\s+POLICIES|ROW\s+POLICY|POLICIES|POLICY|SETTINGS\s+PROFILES|SETTINGS\s+PROFILE|PROFILES|PROFILE|NAMED\s+COLLECTIONS|NAMED\s+COLLECTION)\b/i,
-      );
-      if (showCreateACMatch) {
-        const rawKey = showCreateACMatch[1].toUpperCase().replace(/\s+/g, ' ');
-        // Normalize aliases: POLICY → ROW POLICY, PROFILE → SETTINGS PROFILE.
-        const keyAliases: Record<string, string> = {
-          POLICY: 'ROW POLICY',
-          POLICIES: 'ROW POLICIES',
-          PROFILE: 'SETTINGS PROFILE',
-          PROFILES: 'SETTINGS PROFILES',
-        };
-        const key = keyAliases[rawKey] || rawKey;
-        // The body after the keyword is the name list (and optional FORMAT clause).
-        const afterKeyword = stmt.body.slice(showCreateACMatch[0].length);
-        const formatMatch = afterKeyword.match(/\bFORMAT\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/i);
-        const hasFormat = formatMatch !== null;
-        const nameList = hasFormat
-          ? afterKeyword.slice(0, formatMatch.index).trim()
-          : afterKeyword.trim();
-        const isMulti = /,/.test(nameList);
-        // ROW POLICY: PLURAL with FORMAT, SINGULAR without (regardless of name count).
-        // Others: PLURAL when multi-name and no FORMAT; SINGULAR otherwise.
-        let usePlural: boolean;
-        if (key === 'ROW POLICY' || key === 'ROW POLICIES') {
-          usePlural = hasFormat;
-        } else {
-          usePlural = isMulti && !hasFormat;
-        }
-        const labels: Record<string, [string, string]> = {
-          USER: ['SHOW CREATE USER query', 'SHOW CREATE USERS query'],
-          USERS: ['SHOW CREATE USER query', 'SHOW CREATE USERS query'],
-          ROLE: ['SHOW CREATE ROLE query', 'SHOW CREATE ROLES query'],
-          ROLES: ['SHOW CREATE ROLE query', 'SHOW CREATE ROLES query'],
-          QUOTA: ['SHOW CREATE QUOTA query', 'SHOW CREATE QUOTAS query'],
-          QUOTAS: ['SHOW CREATE QUOTA query', 'SHOW CREATE QUOTAS query'],
-          'ROW POLICY': ['SHOW CREATE ROW POLICY query', 'SHOW CREATE ROW POLICIES query'],
-          'ROW POLICIES': ['SHOW CREATE ROW POLICY query', 'SHOW CREATE ROW POLICIES query'],
-          'SETTINGS PROFILE': [
-            'SHOW CREATE SETTINGS PROFILE query',
-            'SHOW CREATE SETTINGS PROFILES query',
-          ],
-          'SETTINGS PROFILES': [
-            'SHOW CREATE SETTINGS PROFILE query',
-            'SHOW CREATE SETTINGS PROFILES query',
-          ],
-          'NAMED COLLECTION': ['ShowCreateNamedCollectionQuery', 'ShowCreateNamedCollectionQuery'],
-          'NAMED COLLECTIONS': ['ShowCreateNamedCollectionQuery', 'ShowCreateNamedCollectionQuery'],
-        };
-        const pair = labels[key];
-        const label = pair ? pair[usePlural ? 1 : 0] : 'SYSTEM query';
-        if (hasFormat && formatMatch) {
-          return n(label, [n(`Identifier ${formatMatch[1]}`)]);
-        }
-        return n(label);
-      }
-      if (/^SHOW\s+GRANTS\b/i.test(stmt.body)) {
-        const formatMatch = stmt.body.match(/\bFORMAT\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/i);
-        if (formatMatch) return n('ShowGrantsQuery', [n(`Identifier ${formatMatch[1]}`)]);
-        return n('ShowGrantsQuery');
-      }
-      if (/^SHOW\s+FUNCTIONS\b/i.test(stmt.body)) return n('ShowFunctions');
-      if (/^SHOW\s+(?:EXTENDED\s+|FULL\s+)?(?:COLUMNS|FIELDS)\b/i.test(stmt.body))
-        return n('ShowColumns');
-      if (/^SHOW\s+(?:EXTENDED\s+)?(?:INDEX|INDEXES|INDICES|KEYS)\b/i.test(stmt.body))
-        return n('ShowColumns');
-      if (/^SHOW\s+PRIVILEGES\b/i.test(stmt.body)) return n('ShowPrivilegesQuery');
-      if (/^SHOW\s+SETTING\b/i.test(stmt.body)) return n('ShowSetting');
-      // SHOW [CHANGED] SETTINGS → ShowTables
-      if (/^SHOW\s+(?:CHANGED\s+)?SETTINGS\b/i.test(stmt.body)) return n('ShowTables');
-      if (/^SHOW\s+ENGINES\b/i.test(stmt.body)) return n('ShowEngines');
-      if (/^SHOW\s+PROCESSLIST\b/i.test(stmt.body)) return n('ShowProcesslist');
-      if (/^SHOW\s+MERGES\b/i.test(stmt.body)) return n('ShowMerges');
-      if (/^SHOW\s+CLUSTERS?\b/i.test(stmt.body)) return n('ShowTables');
-      if (/^SHOW\s+ACCESS\b/i.test(stmt.body)) return n('ShowAccessQuery');
-      if (/^SHOW\s+(?:CURRENT\s+)?ROLES?\b/i.test(stmt.body)) return n('ShowTables');
-      if (/^SHOW\s+USERS?\b/i.test(stmt.body)) return n('ShowTables');
-      if (/^SHOW\s+QUOTAS?\b/i.test(stmt.body)) return n('ShowTables');
-      if (/^SHOW\s+(?:ROW\s+)?POLIC(?:Y|IES)\b/i.test(stmt.body)) return n('ShowTables');
-      if (/^SHOW\s+(?:SETTINGS\s+)?PROFILES?\b/i.test(stmt.body)) return n('ShowTables');
-      if (/^SHOW\s+(?:NAMED\s+)?COLLECTIONS?\b/i.test(stmt.body)) return n('ShowTables');
-      if (/^SHOW\s+WARNINGS?\b/i.test(stmt.body)) return n('ShowTables');
-      // SHOW TABLES/DATABASES/DICTIONARIES [FROM db [LIKE/NOT LIKE 'x']] [SETTINGS ...] [FORMAT fmt]
-      if (/^SHOW\s+(?:TEMPORARY\s+)?(TABLES|DATABASES|DICTIONARIES)\b/i.test(stmt.body)) {
-        const fromMatch = stmt.body.match(/\b(?:FROM|IN)\s+([A-Za-z_][A-Za-z0-9_]*)\b/i);
-        const formatMatch = stmt.body.match(/\bFORMAT\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/i);
-        const hasSettings = /\bSETTINGS\b/i.test(stmt.body);
-        const children: ExplainNode[] = [];
-        if (fromMatch) children.push(n(`Identifier ${fromMatch[1]}`));
-        if (hasSettings) children.push(n('Set'));
-        if (formatMatch) children.push(n(`Identifier ${formatMatch[1]}`));
-        if (children.length > 0) return n('ShowTables', children);
-        return n('ShowTables');
-      }
-      // SHOW TABLE name / SHOW TEMPORARY VIEW name → equivalent to SHOW CREATE TABLE/VIEW
-      const showTableMatch = stmt.body.match(
-        /^SHOW\s+(TABLE|TEMPORARY\s+VIEW|VIEW)\s+(?:([A-Za-z_][A-Za-z0-9_]*)\.)?([A-Za-z_][A-Za-z0-9_]*)\b/i,
-      );
-      if (showTableMatch) {
-        const kw = showTableMatch[1].toUpperCase().replace(/\s+/g, ' ');
-        const db = showTableMatch[2];
-        const tbl = showTableMatch[3];
-        const children: ExplainNode[] = [];
-        if (db) children.push(n(`Identifier ${db}`));
-        children.push(n(`Identifier ${tbl}`));
-        const formatMatch = stmt.body.match(/\bFORMAT\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/i);
-        if (formatMatch) children.push(n(`Identifier ${formatMatch[1]}`));
-        const prefix = kw === 'TABLE' ? 'ShowCreateTableQuery' : 'ShowCreateViewQuery';
-        const label = db ? `${prefix} ${db} ${tbl}` : `${prefix}  ${tbl}`;
-        return n(label, children);
-      }
-      // SHOW DATABASE name → equivalent to SHOW CREATE DATABASE
-      const showDbMatch = stmt.body.match(/^SHOW\s+DATABASE\s+([A-Za-z_][A-Za-z0-9_]*)\b/i);
-      if (showDbMatch) {
-        const db = showDbMatch[1];
-        const children: ExplainNode[] = [n(`Identifier ${db}`)];
-        const formatMatch = stmt.body.match(/\bFORMAT\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/i);
-        if (formatMatch) children.push(n(`Identifier ${formatMatch[1]}`));
-        return n(`ShowCreateDatabaseQuery ${db} `, children);
-      }
-      return n('SYSTEM query');
-    }
     // SYSTEM subcommands that target a specific table or dictionary include
     // Identifier children in the explain output.
     if (/^SYSTEM\s/i.test(stmt.body)) {
@@ -2737,67 +2669,6 @@ function stmtNode(stmt: Statement): ExplainNode {
       }
       return n('SYSTEM query');
     }
-    // KILL QUERY / KILL MUTATION (fallback when not structurally parsed)
-    if (/^KILL\s/i.test(stmt.body)) {
-      return n('KillQueryQuery');
-    }
-    // BACKUP / RESTORE — extract the TO/FROM destination function and FORMAT.
-    if (/^BACKUP\s/i.test(stmt.body) || /^RESTORE\s/i.test(stmt.body)) {
-      const isRestore = /^RESTORE\s/i.test(stmt.body);
-      const label = isRestore ? 'RestoreQuery' : 'BackupQuery';
-      // Strip trailing FORMAT clause from body so it doesn't bleed into destination match.
-      const formatMatch = stmt.body.match(/\bFORMAT\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/i);
-      let bodyNoFormat = formatMatch ? stmt.body.slice(0, formatMatch.index).trimEnd() : stmt.body;
-      // Strip trailing SETTINGS clause too.
-      const settingsIdx = bodyNoFormat.search(/\bSETTINGS\b/i);
-      if (settingsIdx > 0) bodyNoFormat = bodyNoFormat.slice(0, settingsIdx).trimEnd();
-      // Destination: ` TO|FROM <Name>[('<arg>'[, ...])]` at the end of body.
-      const destMatch = bodyNoFormat.match(
-        /\b(?:TO|FROM)\s+([A-Za-z_][A-Za-z0-9_]*)(\s*\([^)]*\))?\s*$/i,
-      );
-      const children: ExplainNode[] = [];
-      if (destMatch) {
-        const fnName = destMatch[1];
-        const argsPart = destMatch[2] || '';
-        const args: ExplainNode[] = [];
-        const argsRegex = /'([^']*)'/g;
-        let m;
-        while ((m = argsRegex.exec(argsPart)) !== null) {
-          args.push(n(`Literal '${m[1]}'`));
-        }
-        const fnChildren =
-          args.length > 0 ? [n('ExpressionList', args)] : argsPart ? [n('ExpressionList')] : [];
-        children.push(n(`Function ${fnName}`, fnChildren));
-      }
-      if (formatMatch) children.push(n(`Identifier ${formatMatch[1]}`));
-      if (children.length > 0) return n(label, children);
-      return n(label);
-    }
-    // GRANT / REVOKE
-    if (/^GRANT\s/i.test(stmt.body)) return n('GrantQuery');
-    if (/^REVOKE\s/i.test(stmt.body)) return n('GrantQuery');
-    // Transaction control (BEGIN / COMMIT / ROLLBACK)
-    if (/^(BEGIN|COMMIT|ROLLBACK)\b/i.test(stmt.body)) return n('ASTTransactionControl');
-    // UNDROP TABLE [db.]name [UUID '...'] [ON CLUSTER ...] [FORMAT name]
-    if (/^UNDROP\s/i.test(stmt.body)) {
-      const m = stmt.body.match(
-        /^UNDROP\s+TABLE\s+(?:([A-Za-z_0-9][A-Za-z0-9_]*)\.)?([A-Za-z_0-9][A-Za-z0-9_]*)/i,
-      );
-      if (m) {
-        const db = m[1];
-        const tbl = m[2];
-        const children: ExplainNode[] = [];
-        if (db) children.push(n(`Identifier ${db}`));
-        children.push(n(`Identifier ${tbl}`));
-        const formatMatch = stmt.body.match(/\bFORMAT\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/i);
-        if (formatMatch) children.push(n(`Identifier ${formatMatch[1]}`));
-        const label = db ? `UndropQuery ${db}.${tbl}` : `UndropQuery  ${tbl}`;
-        return n(label, children);
-      }
-      return n('UndropQuery');
-    }
-    // EXCHANGE TABLES/DICTIONARIES as system fallback
-    if (/^EXCHANGE\s/i.test(stmt.body)) return n('Rename');
     return n('SYSTEM query');
   }
   if (stmt.kind === 'use')
@@ -2814,7 +2685,7 @@ function stmtNode(stmt: Statement): ExplainNode {
     if (!stmt.auth || stmt.auth.length === 0) return n('CreateUserQuery');
     const authChildren = stmt.auth.map((a) => {
       if (a.sshKeys !== undefined) {
-        const keys = Array.from({ length: a.sshKeys }, () => n('PublicSSHKey'));
+        const keys = a.sshKeys.map(() => n('PublicSSHKey'));
         return n('AuthenticationData', keys);
       }
       if (a.secret !== undefined) {
@@ -3137,6 +3008,49 @@ function stmtNode(stmt: Statement): ExplainNode {
 
     return n(label, children);
   }
+  if (stmt.kind === 'undrop') {
+    const t = stmt.table;
+    const children: ExplainNode[] = [];
+    if (t.database) children.push(n(`Identifier ${id(t.database)}`));
+    children.push(n(`Identifier ${id(t.table)}`));
+    if (stmt.format) children.push(n(`Identifier ${stmt.format}`));
+    const label = t.database
+      ? `UndropQuery ${id(t.database)}.${id(t.table)}`
+      : `UndropQuery  ${id(t.table)}`;
+    return n(label, children);
+  }
+  if (stmt.kind === 'backup') {
+    const label = stmt.operation === 'RESTORE' ? 'RestoreQuery' : 'BackupQuery';
+    const children: ExplainNode[] = [];
+    const d = stmt.destination;
+    const fnChildren: ExplainNode[] =
+      d.args === undefined ? [] : [n('ExpressionList', d.args.map(exprNode))];
+    children.push(n(`Function ${d.name}`, fnChildren));
+    if (stmt.format) children.push(n(`Identifier ${stmt.format}`));
+    return n(label, children);
+  }
+  if (stmt.kind === 'grant') return n('GrantQuery');
+  if (stmt.kind === 'show') return showQueryNode(stmt);
+  if (stmt.kind === 'alterRole') return n('CreateRoleQuery');
+  if (stmt.kind === 'alterQuota') return n('CreateQuotaQuery');
+  if (stmt.kind === 'alterRowPolicy') return n('CREATE ROW POLICY or ALTER ROW POLICY query');
+  if (stmt.kind === 'alterSettingsProfile') return n('CreateSettingsProfileQuery');
+  if (stmt.kind === 'alterUser') {
+    // Mirror CreateUserQuery: emit AuthenticationData children when the statement
+    // (re)sets authentication.
+    let auth: AuthenticationData[] | undefined;
+    for (const c of stmt.clauses) {
+      if (c.kind === 'identified') auth = c.auth;
+      else if (c.kind === 'notIdentified') auth = [{}];
+    }
+    if (!auth || auth.length === 0) return n('CreateUserQuery');
+    const authChildren = auth.map((a) =>
+      a.secret !== undefined
+        ? n('AuthenticationData', [n(`Literal '${a.secret}'`)])
+        : n('AuthenticationData'),
+    );
+    return n('CreateUserQuery', authChildren);
+  }
   if (stmt.kind === 'alter') return alterQueryNode(stmt);
 
   const format = stmt.format;
diff --git a/src/format.ts b/src/format.ts
index c64296f56..0dccdc302 100644
--- a/src/format.ts
+++ b/src/format.ts
@@ -1,8 +1,42 @@
 import {
   AccessControlName,
   AccessControlSettingsItem,
+  AlterCommand,
+  AlterPartitionExpr,
+  AlterQuotaStatement,
+  AlterRoleStatement,
+  AlterRowPolicyStatement,
+  AlterSettingsProfileStatement,
   AlterStatement,
+  AlterUserStatement,
   ASTNode,
+  AttachStatement,
+  AuthenticationData,
+  BackupElement,
+  BackupStatement,
+  CheckStatement,
+  CodecItem,
+  CreateStatement,
+  DataType,
+  DeleteStatement,
+  DescribeStatement,
+  DetachStatement,
+  ExecuteAsStatement,
+  ExistsStatement,
+  GrantPrivilege,
+  GrantStatement,
+  GrantTarget,
+  Identifier,
+  IndexType,
+  KillStatement,
+  OptimizeStatement,
+  RenameStatement,
+  ShowCreateStatement,
+  ShowLike,
+  ShowStatement,
+  TableElement,
+  TruncateStatement,
+  UpdateStatement,
   CTE,
   ColumnTransformer,
   CreateNamedCollectionStatement,
@@ -155,7 +189,7 @@ const KEYWORDS = new Set([
 
 // Quote an identifier with backticks if it needs quoting. Accepts either a
 // plain string or a {@link QueryParam} node (identifier-position query param).
-function quoteIdent(s: import('./ast').Identifier): string {
+function quoteIdent(s: Identifier): string {
   if (typeof s !== 'string') return `{${s.name}:${s.type}}`;
   // Valid bare identifier: starts with letter/underscore, contains only alphanum/underscore/$
   if (/^[a-zA-Z_][a-zA-Z0-9_$]*$/.test(s) && !KEYWORDS.has(s.toUpperCase())) {
@@ -282,6 +316,12 @@ export function formatNode(node: ASTNode, indent: string = ''): string {
     case 'createWindowView':
     case 'createLiveView':
       return formatCreateStatement(node, indent);
+    case 'alterUser':
+    case 'alterRole':
+    case 'alterQuota':
+    case 'alterRowPolicy':
+    case 'alterSettingsProfile':
+      return formatStatement(node, indent);
     case 'columnDef':
     case 'constraintDef':
     case 'indexDef':
@@ -335,6 +375,14 @@ export function formatNode(node: ASTNode, indent: string = ''): string {
       return '';
     case 'drop':
       return formatStatement(node, indent);
+    case 'undrop':
+      return formatStatement(node, indent);
+    case 'backup':
+      return formatStatement(node, indent);
+    case 'grant':
+      return formatStatement(node, indent);
+    case 'show':
+      return formatStatement(node, indent);
     case 'alter':
       return formatAlterStatement(node, indent);
     case 'alterCommand':
@@ -467,7 +515,7 @@ function formatStatement(stmt: Statement, indent: string): string {
   if (stmt.kind === 'executeAs') return formatExecuteAsStatement(stmt, indent);
   if (stmt.kind === 'empty') return '';
   if (stmt.kind === 'drop') {
-    const fmtRef = (t: import('./ast').TableRef) =>
+    const fmtRef = (t: TableRef) =>
       t.database ? `${quoteIdent(t.database)}.${quoteIdent(t.table)}` : quoteIdent(t.table);
     // DROP INDEX has special syntax: DROP INDEX [IF EXISTS] name ON table
     if (stmt.targetType === 'INDEX' && stmt.indexName && stmt.table) {
@@ -492,6 +540,37 @@ function formatStatement(stmt: Statement, indent: string): string {
     if (stmt.format) result += ` FORMAT ${stmt.format}`;
     return result;
   }
+  if (stmt.kind === 'undrop') {
+    const t = stmt.table;
+    const ref = t.database
+      ? `${quoteIdent(t.database)}.${quoteIdent(t.table)}`
+      : quoteIdent(t.table);
+    let result = `${indent}UNDROP TABLE`;
+    if (stmt.ifNotExists) result += ' IF NOT EXISTS';
+    result += ` ${ref}`;
+    if (stmt.uuid !== undefined) result += ` UUID ${formatStringLiteral(stmt.uuid)}`;
+    if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
+    if (stmt.format) result += ` FORMAT ${stmt.format}`;
+    return result;
+  }
+  if (stmt.kind === 'backup') {
+    return formatBackupStatement(stmt, indent);
+  }
+  if (stmt.kind === 'grant') {
+    return formatGrantStatement(stmt, indent);
+  }
+  if (stmt.kind === 'show') {
+    return formatShowStatement(stmt, indent);
+  }
+  if (
+    stmt.kind === 'alterUser' ||
+    stmt.kind === 'alterRole' ||
+    stmt.kind === 'alterQuota' ||
+    stmt.kind === 'alterRowPolicy' ||
+    stmt.kind === 'alterSettingsProfile'
+  ) {
+    return formatAlterAccessStatement(stmt, indent);
+  }
   if (stmt.kind === 'alter') {
     return formatAlterStatement(stmt, indent);
   }
@@ -535,7 +614,16 @@ function formatTransactionControlStatement(
   stmt: TransactionControlStatement,
   indent: string,
 ): string {
-  return `${indent}SET TRANSACTION snapshot ${stmt.snapshot}`;
+  switch (stmt.action) {
+    case 'begin':
+      return `${indent}BEGIN TRANSACTION`;
+    case 'commit':
+      return `${indent}COMMIT`;
+    case 'rollback':
+      return `${indent}ROLLBACK`;
+    case 'snapshot':
+      return `${indent}SET TRANSACTION snapshot ${stmt.snapshot}`;
+  }
 }
 
 function formatSetRoleStatement(stmt: SetRoleStatement, indent: string): string {
@@ -624,17 +712,13 @@ function formatUseStatement(stmt: UseStatement, indent: string): string {
   return `${indent}USE ${quoteIdent(stmt.database)}`;
 }
 
-function formatAlterPartitionExpr(
-  part: import('./ast').AlterPartitionExpr,
-  indent: string,
-): string {
+function formatAlterPartitionExpr(part: AlterPartitionExpr, indent: string): string {
   if (part.partitionKind === 'all') return 'ALL';
-  if (part.partitionKind === 'id')
-    return `ID ${formatExpr(part.id as import('./ast').Expression, indent)}`;
+  if (part.partitionKind === 'id') return `ID ${formatExpr(part.id as Expression, indent)}`;
   return formatExpr(part.expr, indent);
 }
 
-function formatAlterCommand(cmd: import('./ast').AlterCommand, indent: string): string {
+function formatAlterCommand(cmd: AlterCommand, indent: string): string {
   switch (cmd.commandType) {
     case 'ADD_COLUMN': {
       let s = `ADD COLUMN ${formatTableElement(cmd.column, '')}`;
@@ -744,7 +828,10 @@ function formatAlterCommand(cmd: import('./ast').AlterCommand, indent: string):
         return `ATTACH PARTITION ${formatAlterPartitionExpr(cmd.partition, indent)}`;
       return 'ATTACH PARTITION';
     case 'DROP_DETACHED_PARTITION':
-      return `DROP DETACHED PARTITION ${formatAlterPartitionExpr(cmd.partition, indent)}`;
+      if (cmd.partName) return `DROP DETACHED PART ${formatExpr(cmd.partName, indent)}`;
+      return `DROP DETACHED PARTITION ${formatAlterPartitionExpr(cmd.partition!, indent)}`;
+    case 'MODIFY_REFRESH':
+      return `MODIFY REFRESH ${cmd.refresh}`;
     case 'REPLACE_PARTITION':
       return `REPLACE PARTITION ${formatAlterPartitionExpr(cmd.partition, indent)} FROM ${formatTableRef(cmd.fromTable)}`;
     case 'MOVE_PARTITION': {
@@ -831,7 +918,8 @@ function formatAlterStatement(stmt: AlterStatement, indent: string): string {
 }
 
 function formatSystemStatement(stmt: SystemStatement, indent: string): string {
-  // Body always includes the leading keyword (SYSTEM, ALTER, DROP, etc.).
+  // Body always includes the leading keyword (SYSTEM, or DROP for the
+  // access-control DROP fallback).
   return `${indent}${stmt.body}`;
 }
 
@@ -884,7 +972,338 @@ function formatInsertStatement(stmt: InsertStatement, indent: string): string {
   return prefixLines.length > 0 ? `${prefixLines.join('\n')}\n${insertLine}` : insertLine;
 }
 
-function formatTruncateStatement(stmt: import('./ast').TruncateStatement, indent: string): string {
+function formatShowStatement(stmt: ShowStatement, indent: string): string {
+  const fmtRef = (t: TableRef) =>
+    t.database ? `${quoteIdent(t.database)}.${quoteIdent(t.table)}` : quoteIdent(t.table);
+  const fmtLike = (l: ShowLike) => {
+    let s = '';
+    if (l.not) s += 'NOT ';
+    s += l.ilike ? 'ILIKE' : 'LIKE';
+    return `${s} ${formatStringLiteral(l.pattern)}`;
+  };
+  const s = stmt.show;
+  const parts: string[] = ['SHOW'];
+  switch (s.type) {
+    case 'listing': {
+      if (s.temporary) parts.push('TEMPORARY');
+      parts.push(s.objectType);
+      if (s.from !== undefined) parts.push(`FROM ${quoteIdent(s.from)}`);
+      if (s.like) parts.push(fmtLike(s.like));
+      if (s.where) parts.push(`WHERE ${formatExpr(s.where, indent)}`);
+      if (s.limit) parts.push(`LIMIT ${formatExpr(s.limit, indent)}`);
+      if (s.settings && s.settings.length > 0)
+        parts.push(`SETTINGS ${formatSettingsList(s.settings, indent)}`);
+      break;
+    }
+    case 'accessEntities': {
+      if (s.modifier) parts.push(s.modifier);
+      parts.push(s.objectType);
+      if (s.like) parts.push(fmtLike(s.like));
+      if (s.limit) parts.push(`LIMIT ${formatExpr(s.limit, indent)}`);
+      break;
+    }
+    case 'cluster':
+      parts.push('CLUSTER', quoteIdent(s.name));
+      break;
+    case 'columns': {
+      if (s.extended) parts.push('EXTENDED');
+      if (s.full) parts.push('FULL');
+      parts.push(s.keyword, `FROM ${fmtRef(s.table)}`);
+      if (s.from !== undefined) parts.push(`FROM ${quoteIdent(s.from)}`);
+      if (s.like) parts.push(fmtLike(s.like));
+      if (s.where) parts.push(`WHERE ${formatExpr(s.where, indent)}`);
+      if (s.limit) parts.push(`LIMIT ${formatExpr(s.limit, indent)}`);
+      break;
+    }
+    case 'indexes': {
+      if (s.extended) parts.push('EXTENDED');
+      parts.push(s.keyword, `FROM ${fmtRef(s.table)}`);
+      if (s.from !== undefined) parts.push(`FROM ${quoteIdent(s.from)}`);
+      if (s.where) parts.push(`WHERE ${formatExpr(s.where, indent)}`);
+      break;
+    }
+    case 'setting':
+      parts.push('SETTING', quoteIdent(s.name));
+      break;
+    case 'privileges':
+      parts.push('PRIVILEGES');
+      break;
+    case 'engines':
+      parts.push('ENGINES');
+      break;
+    case 'merges':
+      parts.push('MERGES');
+      break;
+    case 'access':
+      parts.push('ACCESS');
+      break;
+    case 'processlist':
+      if (s.full) parts.push('FULL');
+      parts.push('PROCESSLIST');
+      break;
+    case 'functions':
+      parts.push('FUNCTIONS');
+      if (s.like) parts.push(fmtLike(s.like));
+      break;
+    case 'grants':
+      parts.push('GRANTS');
+      if (s.for) parts.push(`FOR ${s.for.join(', ')}`);
+      if (s.withImplicit) parts.push('WITH IMPLICIT');
+      if (s.final) parts.push('FINAL');
+      break;
+    case 'createAccess':
+      parts.push('CREATE', s.entity, s.names.map(formatAccessControlName).join(', '));
+      break;
+    case 'createRowPolicy':
+      parts.push(
+        'CREATE ROW POLICY',
+        s.policies
+          .map((p) =>
+            p.table ? `${p.names.join(', ')} ON ${fmtRef(p.table)}` : p.names.join(', '),
+          )
+          .join(', '),
+      );
+      break;
+    case 'objectShorthand':
+      if (s.temporary) parts.push('TEMPORARY');
+      parts.push(s.objectType, fmtRef(s.table));
+      break;
+    case 'databaseShorthand':
+      parts.push('DATABASE', quoteIdent(s.database));
+      break;
+  }
+  let result = indent + parts.join(' ');
+  if (stmt.format) result += ` FORMAT ${stmt.format}`;
+  return result;
+}
+
+// Formats the text after the IDENTIFIED keyword from an auth-method array.
+// Shared by CREATE USER and ALTER USER (the caller supplies the IDENTIFIED keyword).
+//
+// Note: for password methods the auth-method *type* (e.g. `WITH sha256_password`)
+// is not preserved in the AST — only the secret is stored — so it is not echoed
+// here. SSH keys, by contrast, are reproduced verbatim.
+function formatAuthMethods(auth: AuthenticationData[]): string {
+  const parts = auth
+    .map((a) => {
+      if (a.sshKeys !== undefined) {
+        const keys = a.sshKeys.map(
+          (k) => `KEY '${escapeString(k.key)}' TYPE '${escapeString(k.type)}'`,
+        );
+        return `WITH ssh_key BY ${keys.join(', ')}`;
+      }
+      if (a.secret) return `BY '${escapeString(a.secret)}'`;
+      return '';
+    })
+    .filter(Boolean);
+  return parts.join(', ');
+}
+
+function formatAlterAccessStatement(
+  stmt:
+    | AlterUserStatement
+    | AlterRoleStatement
+    | AlterQuotaStatement
+    | AlterRowPolicyStatement
+    | AlterSettingsProfileStatement,
+  indent: string,
+): string {
+  if (stmt.kind === 'alterUser') {
+    let result = `${indent}ALTER USER`;
+    if (stmt.ifExists) result += ' IF EXISTS';
+    result += ` ${formatAccessControlNames(stmt.names)}`;
+    if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
+    for (const c of stmt.clauses) {
+      switch (c.kind) {
+        case 'rename':
+          result += ` RENAME TO ${formatAccessControlName(c.to)}`;
+          break;
+        case 'identified':
+          result += ` IDENTIFIED ${formatAuthMethods(c.auth)}`;
+          break;
+        case 'notIdentified':
+          result += ' NOT IDENTIFIED';
+          break;
+        case 'host':
+          result += c.mode ? ` ${c.mode} HOST` : ' HOST';
+          result += ` ${formatHostItems(c.hosts)}`;
+          break;
+        case 'settings':
+          result +=
+            c.settings === 'NONE'
+              ? ' SETTINGS NONE'
+              : ` SETTINGS ${formatAccessControlSettings(c.settings, indent)}`;
+          break;
+        case 'defaultRole':
+          result += ` DEFAULT ROLE ${formatRoleTarget(c.roles)}`;
+          break;
+        case 'defaultDatabase':
+          result += ` DEFAULT DATABASE ${quoteIdent(c.database)}`;
+          break;
+        case 'grantees':
+          result += ` GRANTEES ${formatRoleTarget(c.grantees)}`;
+          break;
+        case 'validUntil':
+          result += ` VALID UNTIL ${formatStringLiteral(c.value)}`;
+          break;
+      }
+    }
+    return result;
+  }
+  if (stmt.kind === 'alterRole') {
+    let result = `${indent}ALTER ROLE`;
+    if (stmt.ifExists) result += ' IF EXISTS';
+    result += ` ${formatAccessControlNames(stmt.names)}`;
+    if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
+    if (stmt.renameTo) result += ` RENAME TO ${formatAccessControlName(stmt.renameTo)}`;
+    if (stmt.settings !== undefined)
+      result += ` SETTINGS ${formatAccessControlSettings(stmt.settings, indent)}`;
+    return result;
+  }
+  if (stmt.kind === 'alterQuota') {
+    let result = `${indent}ALTER QUOTA`;
+    if (stmt.ifExists) result += ' IF EXISTS';
+    result += ` ${stmt.names.join(', ')}`;
+    if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
+    if (stmt.renameTo) result += ` RENAME TO ${stmt.renameTo}`;
+    if (stmt.keyed) {
+      result += 'notKeyed' in stmt.keyed ? ' NOT KEYED' : ` KEYED BY ${stmt.keyed.keys.join(', ')}`;
+    }
+    if (stmt.intervals) {
+      for (const interval of stmt.intervals) {
+        result += ' FOR';
+        if (interval.randomized) result += ' RANDOMIZED';
+        result += ` ${interval.duration} ${interval.unit}`;
+        if (interval.trackingOnly) result += ' TRACKING ONLY';
+        else if (interval.noLimits) result += ' NO LIMITS';
+        else if (interval.limits)
+          result +=
+            ' ' +
+            interval.limits.map((l) => `MAX ${l.name} = ${formatExpr(l.value, indent)}`).join(', ');
+      }
+    }
+    if (stmt.to) result += ` TO ${formatRoleTarget(stmt.to)}`;
+    return result;
+  }
+  if (stmt.kind === 'alterRowPolicy') {
+    let result = `${indent}ALTER ${stmt.hasRowKeyword ? 'ROW POLICY' : 'POLICY'}`;
+    if (stmt.ifExists) result += ' IF EXISTS';
+    const targets = stmt.targets
+      .map((t) => `${t.names.join(', ')} ON ${formatTableRef(t.table)}`)
+      .join(', ');
+    result += ` ${targets}`;
+    if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
+    if (stmt.renameTo) result += ` RENAME TO ${stmt.renameTo}`;
+    if (stmt.forSelect) result += ' FOR SELECT';
+    if (stmt.using) result += ` USING ${formatExpr(stmt.using, indent)}`;
+    if (stmt.restrictive) result += ` AS ${stmt.restrictive}`;
+    if (stmt.to) result += ` TO ${formatRoleTarget(stmt.to)}`;
+    return result;
+  }
+  // alterSettingsProfile
+  let result = `${indent}ALTER ${stmt.hasSettingsKeyword ? 'SETTINGS PROFILE' : 'PROFILE'}`;
+  if (stmt.ifExists) result += ' IF EXISTS';
+  result += ` ${stmt.names.join(', ')}`;
+  if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
+  if (stmt.renameTo) result += ` RENAME TO ${stmt.renameTo}`;
+  if (stmt.settings !== undefined)
+    result += ` SETTINGS ${formatAccessControlSettings(stmt.settings, indent)}`;
+  if (stmt.to) result += ` TO ${formatRoleTarget(stmt.to)}`;
+  return result;
+}
+
+function formatGrantStatement(stmt: GrantStatement, indent: string): string {
+  const fmtPriv = (p: GrantPrivilege) =>
+    p.columns && p.columns.length > 0
+      ? `${p.name}(${p.columns.map(quoteIdent).join(', ')})`
+      : p.name;
+  const fmtTarget = (t: GrantTarget) =>
+    t.database !== undefined ? `${t.database}.${t.table}` : t.table;
+  let result = `${indent}${stmt.operation}`;
+  if (stmt.optionFor) result += ` ${stmt.optionFor} OPTION FOR`;
+  if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
+  if (stmt.elements) {
+    result += ` ${stmt.elements
+      .map((el) => `${el.privileges.map(fmtPriv).join(', ')} ON ${fmtTarget(el.target)}`)
+      .join(', ')}`;
+  } else if (stmt.roles) {
+    result += ` ${stmt.roles.join(', ')}`;
+  }
+  result += ` ${stmt.operation === 'REVOKE' ? 'FROM' : 'TO'} ${stmt.grantees.join(', ')}`;
+  if (stmt.withOptions) {
+    for (const opt of stmt.withOptions) result += ` WITH ${opt} OPTION`;
+  }
+  return result;
+}
+
+function formatBackupStatement(stmt: BackupStatement, indent: string): string {
+  const fmtRef = (t: TableRef) =>
+    t.database ? `${quoteIdent(t.database)}.${quoteIdent(t.table)}` : quoteIdent(t.table);
+  const fmtElement = (el: BackupElement): string => {
+    switch (el.kind) {
+      case 'table':
+      case 'dictionary':
+      case 'view':
+      case 'temporaryTable': {
+        const keyword =
+          el.kind === 'temporaryTable'
+            ? 'TEMPORARY TABLE'
+            : el.kind === 'dictionary'
+              ? 'DICTIONARY'
+              : el.kind === 'view'
+                ? 'VIEW'
+                : 'TABLE';
+        let s = `${keyword} ${fmtRef(el.table)}`;
+        if (el.as) s += ` AS ${fmtRef(el.as)}`;
+        if (el.partitions && el.partitions.length > 0) {
+          s += ` PARTITION ${el.partitions.map((p) => formatExpr(p, indent)).join(', ')}`;
+        }
+        if (el.exceptColumns && el.exceptColumns.length > 0) {
+          s += ` EXCEPT COLUMNS (${el.exceptColumns.map(quoteIdent).join(', ')})`;
+        }
+        return s;
+      }
+      case 'database': {
+        let s = `DATABASE ${quoteIdent(el.name)}`;
+        if (el.as) s += ` AS ${quoteIdent(el.as)}`;
+        if (el.exceptTables && el.exceptTables.length > 0) {
+          s += ` EXCEPT TABLES ${el.exceptTables.map(quoteIdent).join(', ')}`;
+        }
+        return s;
+      }
+      case 'function':
+        return `FUNCTION ${quoteIdent(el.name)}`;
+      case 'namedCollection':
+        return `NAMED COLLECTION ${quoteIdent(el.name)}`;
+      case 'all': {
+        let s = 'ALL';
+        if (el.exceptDatabases && el.exceptDatabases.length > 0) {
+          s += ` EXCEPT DATABASES ${el.exceptDatabases.map(quoteIdent).join(', ')}`;
+        }
+        if (el.exceptTables && el.exceptTables.length > 0) {
+          s += ` EXCEPT TABLES ${el.exceptTables.map(fmtRef).join(', ')}`;
+        }
+        return s;
+      }
+    }
+  };
+  const d = stmt.destination;
+  let dest = d.name;
+  if (d.args !== undefined) {
+    dest += `(${d.args.map((a) => formatExpr(a, indent)).join(', ')})`;
+  }
+  let result = `${indent}${stmt.operation} ${stmt.elements.map(fmtElement).join(', ')}`;
+  result += ` ${stmt.operation === 'RESTORE' ? 'FROM' : 'TO'} ${dest}`;
+  if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
+  if (stmt.settings && stmt.settings.length > 0) {
+    result += ` SETTINGS ${formatSettingsList(stmt.settings, indent)}`;
+  }
+  if (stmt.wait) result += ` ${stmt.wait}`;
+  if (stmt.format) result += ` FORMAT ${stmt.format}`;
+  return result;
+}
+
+function formatTruncateStatement(stmt: TruncateStatement, indent: string): string {
   const parts: string[] = [`${indent}TRUNCATE`];
   if (stmt.targetType === 'TABLES') {
     if (stmt.allTables) parts.push('ALL');
@@ -917,7 +1336,7 @@ function formatTruncateStatement(stmt: import('./ast').TruncateStatement, indent
   return parts.join(' ');
 }
 
-function formatOptimizeStatement(stmt: import('./ast').OptimizeStatement, indent: string): string {
+function formatOptimizeStatement(stmt: OptimizeStatement, indent: string): string {
   let result = `${indent}OPTIMIZE TABLE ${formatTableRef(stmt.table)}`;
   if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
   if (stmt.partition) {
@@ -943,7 +1362,7 @@ function formatOptimizeStatement(stmt: import('./ast').OptimizeStatement, indent
   return result;
 }
 
-function formatDescribeStatement(stmt: import('./ast').DescribeStatement, indent: string): string {
+function formatDescribeStatement(stmt: DescribeStatement, indent: string): string {
   let target: string;
   if (stmt.target.kind === 'table') {
     target = formatTableRef(stmt.target.table);
@@ -966,10 +1385,7 @@ function formatDescribeStatement(stmt: import('./ast').DescribeStatement, indent
   return result;
 }
 
-function formatShowCreateStatement(
-  stmt: import('./ast').ShowCreateStatement,
-  indent: string,
-): string {
+function formatShowCreateStatement(stmt: ShowCreateStatement, indent: string): string {
   let result: string;
   if (stmt.targetType === 'DATABASE') {
     result = `${indent}SHOW CREATE DATABASE ${quoteIdent(stmt.database!)}`;
@@ -983,7 +1399,7 @@ function formatShowCreateStatement(
   return result;
 }
 
-function formatDetachStatement(stmt: import('./ast').DetachStatement, indent: string): string {
+function formatDetachStatement(stmt: DetachStatement, indent: string): string {
   const parts: string[] = [`${indent}DETACH`, stmt.targetType];
   if (stmt.ifExists) parts.push('IF EXISTS');
   if (stmt.targetType === 'DATABASE') {
@@ -997,7 +1413,7 @@ function formatDetachStatement(stmt: import('./ast').DetachStatement, indent: st
   return parts.join(' ');
 }
 
-function formatDeleteStatement(stmt: import('./ast').DeleteStatement, indent: string): string {
+function formatDeleteStatement(stmt: DeleteStatement, indent: string): string {
   let result = `${indent}DELETE FROM ${formatTableRef(stmt.table)}`;
   if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
   if (stmt.partition) {
@@ -1014,7 +1430,7 @@ function formatDeleteStatement(stmt: import('./ast').DeleteStatement, indent: st
   return result;
 }
 
-function formatUpdateStatement(stmt: import('./ast').UpdateStatement, indent: string): string {
+function formatUpdateStatement(stmt: UpdateStatement, indent: string): string {
   let result = `${indent}UPDATE ${formatTableRef(stmt.table)}`;
   if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
   const sets = stmt.assignments
@@ -1027,7 +1443,7 @@ function formatUpdateStatement(stmt: import('./ast').UpdateStatement, indent: st
   return result;
 }
 
-function formatCheckStatement(stmt: import('./ast').CheckStatement, indent: string): string {
+function formatCheckStatement(stmt: CheckStatement, indent: string): string {
   let result: string;
   if (stmt.targetType === 'ALL') {
     result = `${indent}CHECK ALL TABLES`;
@@ -1050,7 +1466,7 @@ function formatCheckStatement(stmt: import('./ast').CheckStatement, indent: stri
   return result;
 }
 
-function formatAttachStatement(stmt: import('./ast').AttachStatement, indent: string): string {
+function formatAttachStatement(stmt: AttachStatement, indent: string): string {
   const parts: string[] = [`${indent}ATTACH`, stmt.targetType];
   if (stmt.ifNotExists) parts.push('IF NOT EXISTS');
   if (stmt.targetType === 'DATABASE') {
@@ -1063,7 +1479,7 @@ function formatAttachStatement(stmt: import('./ast').AttachStatement, indent: st
   return parts.join(' ');
 }
 
-function formatRenameStatement(stmt: import('./ast').RenameStatement, indent: string): string {
+function formatRenameStatement(stmt: RenameStatement, indent: string): string {
   const keyword = stmt.exchange ? 'EXCHANGE' : 'RENAME';
   const pairs = stmt.pairs
     .map((p) => `${formatTableRef(p.from)} ${stmt.exchange ? 'AND' : 'TO'} ${formatTableRef(p.to)}`)
@@ -1078,7 +1494,7 @@ function formatRenameStatement(stmt: import('./ast').RenameStatement, indent: st
   return result;
 }
 
-function formatExistsStatement(stmt: import('./ast').ExistsStatement, indent: string): string {
+function formatExistsStatement(stmt: ExistsStatement, indent: string): string {
   const target =
     stmt.targetType === 'DATABASE' ? quoteIdent(stmt.database!) : formatTableRef(stmt.table!);
   let result = `${indent}EXISTS ${stmt.targetType} ${target}`;
@@ -1088,14 +1504,11 @@ function formatExistsStatement(stmt: import('./ast').ExistsStatement, indent: st
   return result;
 }
 
-function formatExecuteAsStatement(
-  stmt: import('./ast').ExecuteAsStatement,
-  indent: string,
-): string {
+function formatExecuteAsStatement(stmt: ExecuteAsStatement, indent: string): string {
   return `${indent}EXECUTE AS ${quoteIdent(stmt.user)} ${formatStatement(stmt.statement, indent)}`;
 }
 
-function formatKillStatement(stmt: import('./ast').KillStatement, indent: string): string {
+function formatKillStatement(stmt: KillStatement, indent: string): string {
   let result = `${indent}KILL ${stmt.target}`;
   if (stmt.onCluster) result += ` ON CLUSTER ${quoteIdent(stmt.onCluster)}`;
   result += ` WHERE ${formatExpr(stmt.where, indent)}`;
@@ -1108,7 +1521,7 @@ function formatKillStatement(stmt: import('./ast').KillStatement, indent: string
 }
 
 function formatCreateStatement(
-  stmt: Exclude<import('./ast').CreateStatement, CreateTableStatement>,
+  stmt: Exclude<CreateStatement, CreateTableStatement>,
   indent: string,
 ): string {
   switch (stmt.kind) {
@@ -1186,7 +1599,7 @@ function formatCreateMaterializedViewStatement(
   }
   if (stmt.toTable) result += `\nTO ${formatTableRef(stmt.toTable)}`;
   const mvPkInSchema = (stmt as Record<string, unknown>).primaryKeyInSchema as
-    | import('./ast').Expression[]
+    | Expression[]
     | undefined;
   if (stmt.tableElements || mvPkInSchema) {
     const innerIndent = indent + '    ';
@@ -1272,12 +1685,12 @@ function formatCreateDictionaryStatement(stmt: CreateDictionaryStatement, indent
       .map((p) => {
         // STRUCTURE value is an array of {name, type} column defs
         if (Array.isArray(p.value)) {
-          const cols = (p.value as { name: string; type: import('./ast').DataType }[])
+          const cols = (p.value as { name: string; type: DataType }[])
             .map((c) => `${quoteIdent(c.name)} ${formatDataType(c.type)}`)
             .join(' ');
           return `${p.name} (${cols})`;
         }
-        return `${p.name} ${formatExpr(p.value as import('./ast').Expression, indent)}`;
+        return `${p.name} ${formatExpr(p.value as Expression, indent)}`;
       })
       .join(' ');
     result += `\nSOURCE(${def.source.name}(${pairs}))`;
@@ -1330,25 +1743,8 @@ function formatCreateUserStatement(stmt: CreateUserStatement, indent: string): s
     if (allEmpty && Object.keys(stmt.auth[0]).length === 0) {
       result += ' NOT IDENTIFIED';
     } else {
-      const authParts = stmt.auth
-        .map((a) => {
-          if (a.sshKeys !== undefined) {
-            // SSH keys: emit placeholder keys
-            const keys = Array.from(
-              { length: a.sshKeys },
-              (_, i) => `KEY 'key${i}' TYPE 'ssh-rsa'`,
-            );
-            return `WITH ssh_key BY ${keys.join(', ')}`;
-          }
-          if (a.secret) {
-            return `BY '${escapeString(a.secret)}'`;
-          }
-          return '';
-        })
-        .filter(Boolean);
-      if (authParts.length > 0) {
-        result += ` IDENTIFIED ${authParts.join(', ')}`;
-      }
+      const auth = formatAuthMethods(stmt.auth);
+      if (auth) result += ` IDENTIFIED ${auth}`;
     }
   }
   if (stmt.onCluster) result += ` ON CLUSTER ${stmt.onCluster}`;
@@ -1654,7 +2050,7 @@ function formatEngine(engine: CreateTableStatement['engine'] & {}, indent: strin
   return result;
 }
 
-function formatDataType(dt: import('./ast').DataType): string {
+function formatDataType(dt: DataType): string {
   if (!dt.args) return dt.name;
   if (dt.args.length === 0) return `${dt.name}()`;
   const args = dt.args.map((a) => {
@@ -1680,7 +2076,7 @@ function formatDataType(dt: import('./ast').DataType): string {
   return `${dt.name}(${args.join(', ')})`;
 }
 
-function formatCodecItems(items: import('./ast').CodecItem[]): string {
+function formatCodecItems(items: CodecItem[]): string {
   const fmtCodecName = (name: string) =>
     /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name) ? name : quoteIdent(name);
   const parts = items.map((c) => {
@@ -1693,7 +2089,7 @@ function formatCodecItems(items: import('./ast').CodecItem[]): string {
   return parts.join(', ');
 }
 
-function formatIndexType(it: import('./ast').IndexType): string {
+function formatIndexType(it: IndexType): string {
   if (it.args !== undefined && it.args.length > 0) {
     return `${it.name}(${it.args.map((a) => formatExpr(a, '')).join(', ')})`;
   }
@@ -1701,7 +2097,7 @@ function formatIndexType(it: import('./ast').IndexType): string {
   return it.name;
 }
 
-function formatTableElement(el: import('./ast').TableElement, indent: string): string {
+function formatTableElement(el: TableElement, indent: string): string {
   switch (el.kind) {
     case 'columnDef': {
       const parts = [`${indent}${quoteIdent(el.name)}`];
diff --git a/src/grammar.pegjs b/src/grammar.pegjs
index 98f4215e8..236ef9a98 100644
--- a/src/grammar.pegjs
+++ b/src/grammar.pegjs
@@ -135,16 +135,22 @@ TopLevelStatement
   = ExplainStatement
   / ParallelWithStatement
   / CreateStatement
+  / AlterAccessStatement
   / AlterStatement
   / SetStatement
+  / TransactionControlStatement
   / UseStatement
   / SystemStatement
   / InsertStatement
   / DropStatement
+  / UndropStatement
+  / BackupStatement
+  / GrantStatement
   / TruncateStatement
   / OptimizeStatement
   / DescribeStatement
   / ShowCreateStatement
+  / ShowStatement
   / DetachStatement
   / DeleteStatement
   / UpdateStatement
@@ -154,7 +160,6 @@ TopLevelStatement
   / ExistsStatement
   / KillStatement
   / ExecuteAsStatement
-  / OpaqueStatement
   / query:UnionQuery intoOutfile:( _ IntoOutfileClause )? preSettings:( _ SettingsClause )? format:( _ FormatClause )? postSettings:( _ SettingsClause )* {
       let result = query;
       if (intoOutfile !== null) {
@@ -187,7 +192,7 @@ ExecuteAsStatement
          / DetachStatement / AttachStatement / DeleteStatement / UpdateStatement
          / CheckStatement / RenameStatement / ExistsStatement / KillStatement
          / TruncateStatement / DropStatement / InsertStatement / CreateStatement
-         / UnionQuery / OpaqueStatement ) {
+         / UnionQuery ) {
       return loc({ kind: 'executeAs', user, statement: stmt });
     }
 
@@ -200,7 +205,7 @@ ImplicitSelectStatement
 
 // SetStatement: SET key = value [, key = value ...] — changes session-level settings
 SetStatement
-  = "SET"i ![a-zA-Z0-9_] _ "TRANSACTION"i ![a-zA-Z0-9_] _ "SNAPSHOT"i ![a-zA-Z0-9_] _ snapshot:$[0-9]+ { return loc({ kind: 'transactionControl', snapshot }); }
+  = "SET"i ![a-zA-Z0-9_] _ "TRANSACTION"i ![a-zA-Z0-9_] _ "SNAPSHOT"i ![a-zA-Z0-9_] _ snapshot:$[0-9]+ { return loc({ kind: 'transactionControl', action: 'snapshot', snapshot }); }
   / "SET"i ![a-zA-Z0-9_] _ "DEFAULT"i ![a-zA-Z0-9_] _ "ROLE"i ![a-zA-Z0-9_] _ roles:SetRoleList _ "TO"i ![a-zA-Z0-9_] _ users:SetRoleUserList { return loc({ kind: 'setRole', roles, users }); }
   / "SET"i ![a-zA-Z0-9_] _ items:SettingsList { return loc({ kind: 'set', settings: items }); }
 
@@ -209,11 +214,18 @@ SetRoleList
   / "NONE"i ![a-zA-Z0-9_] { return { kind: 'none' }; }
   / names:SetRoleNameList { return { kind: 'names', names }; }
 
+// A comma-separated list of identifiers (see AliasNameList).
 SetRoleNameList
-  = head:AliasName tail:( _ "," _ AliasName )* { return [head, ...tail.map(t => t[3])]; }
+  = AliasNameList
 
 SetRoleUserList
-  = head:AliasName tail:( _ "," _ AliasName )* { return [head, ...tail.map(t => t[3])]; }
+  = AliasNameList
+
+// TransactionControlStatement: BEGIN [TRANSACTION], START TRANSACTION, COMMIT, ROLLBACK
+TransactionControlStatement
+  = ("BEGIN"i / "START"i) ![a-zA-Z0-9_] ( _ "TRANSACTION"i ![a-zA-Z0-9_] )? { return loc({ kind: 'transactionControl', action: 'begin' }); }
+  / "COMMIT"i ![a-zA-Z0-9_] { return loc({ kind: 'transactionControl', action: 'commit' }); }
+  / "ROLLBACK"i ![a-zA-Z0-9_] { return loc({ kind: 'transactionControl', action: 'rollback' }); }
 
 // UseStatement: USE database — selects the current database
 UseStatement
@@ -264,6 +276,7 @@ AlterCommandInner
   / AlterCommandModifySetting
   / AlterCommandResetSetting
   / AlterCommandModifyQuery
+  / AlterCommandModifyRefresh
   / AlterCommandModifyComment
   / AlterCommandAddIndex
   / AlterCommandDropIndex
@@ -631,7 +644,7 @@ AlterCommandMaterializeStatistics
     }
 
 AlterStatisticsColumns
-  = head:AliasName tail:( _ "," _ AliasName )* { return [head, ...tail.map(t => t[3])]; }
+  = AliasNameList
 
 AlterStatisticsTypes
   = head:IndexTypeSpec tail:( _ "," _ IndexTypeSpec )* { return [head, ...tail.map(t => t[3])]; }
@@ -678,7 +691,7 @@ AlterCommandDelete
 // ── Partition commands ──────────────────────────────────────────────────────
 
 AlterCommandDropPartition
-  = ("DROP"i / "DETACH"i) ![a-zA-Z0-9_] _ "PART"i ![a-zA-Z0-9_] _ partName:StringLiteral {
+  = ("DROP"i / "DETACH"i) ![a-zA-Z0-9_] _ "PART"i ![a-zA-Z0-9_] _ partName:( StringLiteral / QueryParam ) {
       return loc({ kind: 'alterCommand', commandType: 'DROP_PARTITION', partName: partName });
     }
   / ("DROP"i / "DETACH"i) ![a-zA-Z0-9_] _ "PARTITION"i ![a-zA-Z0-9_] _ part:AlterPartitionExpr {
@@ -686,12 +699,15 @@ AlterCommandDropPartition
     }
 
 AlterCommandDropDetachedPartition
-  = "DROP"i ![a-zA-Z0-9_] _ "DETACHED"i ![a-zA-Z0-9_] _ "PARTITION"i ![a-zA-Z0-9_] _ part:AlterPartitionExpr {
+  = "DROP"i ![a-zA-Z0-9_] _ "DETACHED"i ![a-zA-Z0-9_] _ "PART"i ![a-zA-Z0-9_] _ partName:( StringLiteral / QueryParam ) {
+      return loc({ kind: 'alterCommand', commandType: 'DROP_DETACHED_PARTITION', partName: partName });
+    }
+  / "DROP"i ![a-zA-Z0-9_] _ "DETACHED"i ![a-zA-Z0-9_] _ "PARTITION"i ![a-zA-Z0-9_] _ part:AlterPartitionExpr {
       return loc({ kind: 'alterCommand', commandType: 'DROP_DETACHED_PARTITION', partition: part });
     }
 
 AlterCommandAttachPartition
-  = "ATTACH"i ![a-zA-Z0-9_] _ "PART"i ![a-zA-Z0-9_] _ partName:StringLiteral {
+  = "ATTACH"i ![a-zA-Z0-9_] _ "PART"i ![a-zA-Z0-9_] _ partName:( StringLiteral / QueryParam ) {
       return loc({ kind: 'alterCommand', commandType: 'ATTACH_PARTITION', partName: partName });
     }
   / "ATTACH"i ![a-zA-Z0-9_] _ "PARTITION"i ![a-zA-Z0-9_] _ part:AlterPartitionExpr _ "FROM"i ![a-zA-Z0-9_] _ fromTable:TableRef {
@@ -789,7 +805,7 @@ AlterCommandResetSetting
     }
 
 AlterResetSettingNames
-  = head:AliasName tail:( _ "," _ AliasName )* { return [head, ...tail.map(t => t[3])]; }
+  = AliasNameList
 
 AlterCommandModifyQuery
   = "MODIFY"i ![a-zA-Z0-9_] _ "QUERY"i ![a-zA-Z0-9_] _ query:UnionQuery {
@@ -801,6 +817,11 @@ AlterCommandModifyComment
       return loc({ kind: 'alterCommand', commandType: 'MODIFY_COMMENT', comment });
     }
 
+AlterCommandModifyRefresh
+  = "MODIFY"i ![a-zA-Z0-9_] _ refresh:RefreshClause {
+      return loc({ kind: 'alterCommand', commandType: 'MODIFY_REFRESH', refresh });
+    }
+
 // ── Other commands ──────────────────────────────────────────────────────────
 
 AlterCommandApplyDeletedMask
@@ -840,11 +861,6 @@ AlterInPartitionClause
   = "IN"i ![a-zA-Z0-9_] _ "PARTITION"i ![a-zA-Z0-9_] _ part:AlterPartitionExpr { return part; }
   / "IN"i ![a-zA-Z0-9_] _ "PART"i ![a-zA-Z0-9_] _ id:StringLiteral { return { partitionKind: 'id', id }; }
 
-// OpaqueStatement: access-control and other DDL we don't yet parse structurally.
-// TRUNCATE is intentionally excluded — it's handled by TruncateStatement above.
-OpaqueStatement
-  = keyword:( "ALTER"i / "ATTACH"i / "DETACH"i / "RENAME"i / "EXCHANGE"i / "CHECK"i / "EXISTS"i / "SHOW"i / "GRANT"i / "REVOKE"i / "KILL"i / "UNDO"i / "BACKUP"i / "RESTORE"i / "BEGIN"i / "COMMIT"i / "ROLLBACK"i / "WATCH"i / "UNDROP"i / "MOVE"i ) ![a-zA-Z0-9_] _ body:$( ![\n;] . )* { return loc({ kind: 'system', body: (keyword + ' ' + body).trim() }); }
-
 // ── DROP statements ─────────────────────────────────────────────────────────
 
 // DropIndexStatement: DROP INDEX [IF EXISTS] name ON [db.]table
@@ -883,6 +899,455 @@ DropStatement
     }
   / body:$( "DROP"i ![a-zA-Z0-9_] ( "'" ( "''" / "\\'" / "\\\\" / !"'" ( [\n\r] / . ) )* "'" / !";" ( [\n\r] / . ) )* ) { return loc({ kind: 'system', body: body.trim() }); }
 
+// UndropStatement: UNDROP TABLE [IF NOT EXISTS] [db.]name [UUID 'x'] [ON CLUSTER c] [FORMAT f]
+UndropStatement
+  = "UNDROP"i ![a-zA-Z0-9_] _ "TABLE"i ![a-zA-Z0-9_]
+    ifne:( _ "IF"i ![a-zA-Z0-9_] _ "NOT"i ![a-zA-Z0-9_] _ "EXISTS"i ![a-zA-Z0-9_] )?
+    _ table:TableRef
+    uuid:( _ "UUID"i ![a-zA-Z0-9_] _ StringLiteral )?
+    cluster:( _ OnClusterClause )?
+    format:( _ FormatClause )? {
+      const result = { kind: 'undrop', table };
+      if (ifne !== null) result.ifNotExists = true;
+      if (uuid !== null) result.uuid = uuid[3].value;
+      if (cluster !== null) result.onCluster = cluster[1];
+      if (format !== null) result.format = format[1];
+      return loc(result);
+    }
+
+// BackupStatement: BACKUP/RESTORE target_list TO/FROM destination [ON CLUSTER] [SETTINGS] [SYNC|ASYNC] [FORMAT]
+BackupStatement
+  = op:( "BACKUP"i / "RESTORE"i ) ![a-zA-Z0-9_] _ elements:BackupElementList
+    _ ( "TO"i / "FROM"i ) ![a-zA-Z0-9_] _ destination:BackupDestination
+    cluster:( _ OnClusterClause )?
+    settings:( _ SettingsClause )?
+    wait:( _ ( "SYNC"i / "ASYNC"i ) ![a-zA-Z0-9_] )?
+    format:( _ FormatClause )? {
+      const result = { kind: 'backup', operation: op.toUpperCase(), elements, destination };
+      if (cluster !== null) result.onCluster = cluster[1];
+      if (settings !== null) result.settings = settings[1];
+      if (wait !== null) result.wait = wait[1].toUpperCase();
+      if (format !== null) result.format = format[1];
+      return loc(result);
+    }
+
+BackupElementList
+  = "ALL"i ![a-zA-Z0-9_] ( _ "DATABASES"i ![a-zA-Z0-9_] )?
+    exceptDbs:( _ "EXCEPT"i ![a-zA-Z0-9_] _ "DATABASES"i ![a-zA-Z0-9_] _ AliasNameList )?
+    exceptTbls:( _ "EXCEPT"i ![a-zA-Z0-9_] _ "TABLES"i ![a-zA-Z0-9_] _ BackupTableRefList )? {
+      const result = { kind: 'all' };
+      if (exceptDbs !== null) result.exceptDatabases = exceptDbs[6];
+      if (exceptTbls !== null) result.exceptTables = exceptTbls[6];
+      return [result];
+    }
+  / head:BackupElement tail:( _ "," _ BackupElement )* { return [head, ...tail.map(t => t[3])]; }
+
+BackupElement
+  = "TEMPORARY"i ![a-zA-Z0-9_] _ "TABLE"i ![a-zA-Z0-9_] _ table:TableRef as:BackupAsTable? {
+      const result = { kind: 'temporaryTable', table };
+      if (as !== null) result.as = as;
+      return result;
+    }
+  / "TABLE"i ![a-zA-Z0-9_] _ table:TableRef as:BackupAsTable? parts:( _ BackupPartitions )? except:( _ BackupExceptColumns )? {
+      const result = { kind: 'table', table };
+      if (as !== null) result.as = as;
+      if (parts !== null) result.partitions = parts[1];
+      if (except !== null) result.exceptColumns = except[1];
+      return result;
+    }
+  / "DICTIONARY"i ![a-zA-Z0-9_] _ table:TableRef as:BackupAsTable? {
+      const result = { kind: 'dictionary', table };
+      if (as !== null) result.as = as;
+      return result;
+    }
+  / "VIEW"i ![a-zA-Z0-9_] _ table:TableRef as:BackupAsTable? {
+      const result = { kind: 'view', table };
+      if (as !== null) result.as = as;
+      return result;
+    }
+  / "DATABASE"i ![a-zA-Z0-9_] _ name:AliasName as:( _ KW_AS _ AliasName )? except:( _ "EXCEPT"i ![a-zA-Z0-9_] _ "TABLES"i ![a-zA-Z0-9_] _ AliasNameList )? {
+      const result = { kind: 'database', name };
+      if (as !== null) result.as = as[3];
+      if (except !== null) result.exceptTables = except[6];
+      return result;
+    }
+  / "FUNCTION"i ![a-zA-Z0-9_] _ name:AliasName { return { kind: 'function', name }; }
+  / "NAMED"i ![a-zA-Z0-9_] _ "COLLECTION"i ![a-zA-Z0-9_] _ name:AliasName { return { kind: 'namedCollection', name }; }
+
+BackupAsTable
+  = _ KW_AS _ table:TableRef { return table; }
+
+BackupPartitions
+  = ( "PARTITIONS"i / "PARTITION"i ) ![a-zA-Z0-9_] _ list:ExpressionList { return list; }
+
+BackupExceptColumns
+  = "EXCEPT"i ![a-zA-Z0-9_] _ "COLUMNS"i ![a-zA-Z0-9_] _ "(" _ list:AliasNameList _ ")" { return list; }
+  / "EXCEPT"i ![a-zA-Z0-9_] _ "COLUMNS"i ![a-zA-Z0-9_] _ list:AliasNameList { return list; }
+
+BackupTableRefList
+  = head:TableRef tail:( _ "," _ TableRef )* { return [head, ...tail.map(t => t[3])]; }
+
+BackupDestination
+  = name:AliasName args:( _ "(" _ ExpressionList? _ ")" )? {
+      const result = { name };
+      if (args !== null) result.args = args[3] || [];
+      return result;
+    }
+
+AliasNameList
+  = head:AliasName tail:( _ "," _ AliasName )* { return [head, ...tail.map(t => t[3])]; }
+
+// GrantStatement: GRANT/REVOKE (priv ON target){,...}|roles TO/FROM grantees [WITH ... OPTION]
+GrantStatement
+  = op:( "GRANT"i / "REVOKE"i ) ![a-zA-Z0-9_]
+    optionFor:( _ ( "GRANT"i / "ADMIN"i ) ![a-zA-Z0-9_] _ "OPTION"i ![a-zA-Z0-9_] _ "FOR"i ![a-zA-Z0-9_] )?
+    cluster:( _ OnClusterClause )?
+    _ body:( elements:GrantElementList { return { elements }; } / roles:GrantRoleList { return { roles }; } )
+    _ ( "TO"i / "FROM"i ) ![a-zA-Z0-9_] _ grantees:GranteeList
+    withOpts:( _ "WITH"i ![a-zA-Z0-9_] _ ( "GRANT"i / "ADMIN"i / "REPLACE"i ) ![a-zA-Z0-9_] _ "OPTION"i ![a-zA-Z0-9_] )* {
+      const result = { kind: 'grant', operation: op.toUpperCase() };
+      if (body.elements !== undefined) result.elements = body.elements;
+      else result.roles = body.roles;
+      result.grantees = grantees;
+      if (optionFor !== null) result.optionFor = optionFor[1].toUpperCase();
+      if (cluster !== null) result.onCluster = cluster[1];
+      if (withOpts.length > 0) result.withOptions = withOpts.map(w => w[4].toUpperCase());
+      return loc(result);
+    }
+
+GrantElementList
+  = head:GrantElement tail:( _ "," _ GrantElement )* { return [head, ...tail.map(t => t[3])]; }
+
+GrantElement
+  = privileges:GrantPrivilegeList _ "ON"i ![a-zA-Z0-9_] _ target:GrantTarget { return { privileges, target }; }
+
+GrantRoleList
+  = head:GrantPrivilege tail:( _ "," _ GrantPrivilege )* { return [head, ...tail.map(t => t[3])].map(p => p.name); }
+
+GrantPrivilegeList
+  = head:GrantPrivilege tail:( _ "," _ GrantPrivilege )* { return [head, ...tail.map(t => t[3])]; }
+
+GrantPrivilege
+  = words:GrantPrivilegeWords columns:( _ "(" _ AliasNameList _ ")" )? {
+      const result = { name: words.join(' ') };
+      if (columns !== null) result.columns = columns[3];
+      return result;
+    }
+
+GrantPrivilegeWords
+  = head:GrantPrivilegeWord tail:( _ GrantPrivilegeWord )* { return [head, ...tail.map(t => t[1])]; }
+
+GrantPrivilegeWord
+  = !( ( "ON"i / "TO"i / "FROM"i / "WITH"i ) ![a-zA-Z0-9_] ) w:$( [a-zA-Z_] [a-zA-Z0-9_]* ) { return w; }
+
+// privilege_target: '*' | '*.*' | db.* | db.table | identifier (with optional '*' suffix on parts)
+GrantTarget
+  = db:GrantTargetPart _ "." _ tbl:GrantTargetPart { return { database: db, table: tbl }; }
+  / tbl:GrantTargetPart { return { table: tbl }; }
+
+GrantTargetPart
+  = "*" { return '*'; }
+  / name:$( [a-zA-Z_$] [a-zA-Z0-9_$]* "*"? ) { return name; }
+  / "`" chars:BacktickChar* "`" { return chars.join(""); }
+
+GranteeList
+  = head:GranteeName tail:( _ "," _ GranteeName )* { return [head, ...tail.map(t => t[3])]; }
+
+GranteeName
+  = "CURRENT_USER"i ![a-zA-Z0-9_] { return 'CURRENT_USER'; }
+  / name:CreateUserNameItem {
+      return name.host !== undefined ? name.name + '@' + name.host : name.name;
+    }
+
+// ── ALTER access-control statements ──────────────────────────────────────────
+AlterAccessStatement
+  = AlterUserStatement
+  / AlterRoleStatement
+  / AlterQuotaStatement
+  / AlterRowPolicyStatement
+  / AlterSettingsProfileStatement
+
+AlterUserStatement
+  = "ALTER"i ![a-zA-Z0-9_] _ "USER"i ![a-zA-Z0-9_]
+    ifExists:( _ "IF"i ![a-zA-Z0-9_] _ "EXISTS"i ![a-zA-Z0-9_] )?
+    _ names:CreateUserNameList
+    cluster:( _ OnClusterClause )?
+    clauses:( _ AlterUserClause )* {
+      const result = { kind: 'alterUser', names, clauses: clauses.map(c => c[1]) };
+      if (ifExists !== null) result.ifExists = true;
+      if (cluster !== null) result.onCluster = cluster[1];
+      return loc(result);
+    }
+
+AlterUserClause
+  = "RENAME"i ![a-zA-Z0-9_] _ "TO"i ![a-zA-Z0-9_] _ to:CreateUserNameItem { return { kind: 'rename', to }; }
+  / "NOT"i ![a-zA-Z0-9_] _ "IDENTIFIED"i ![a-zA-Z0-9_] { return { kind: 'notIdentified' }; }
+  / "IDENTIFIED"i ![a-zA-Z0-9_] _ auth:CreateUserAuthMethods { return { kind: 'identified', auth }; }
+  / mode:( "ADD"i / "DROP"i ) ![a-zA-Z0-9_] _ "HOST"i ![a-zA-Z0-9_] _ hosts:HostItemList { return { kind: 'host', mode: mode.toUpperCase(), hosts }; }
+  / "HOST"i ![a-zA-Z0-9_] _ hosts:HostItemList { return { kind: 'host', hosts }; }
+  / "SETTINGS"i ![a-zA-Z0-9_] _ "NONE"i ![a-zA-Z0-9_] { return { kind: 'settings', settings: 'NONE' }; }
+  / "SETTINGS"i ![a-zA-Z0-9_] _ items:AccessControlSettingsList { return { kind: 'settings', settings: items }; }
+  / "DEFAULT"i ![a-zA-Z0-9_] _ "ROLE"i ![a-zA-Z0-9_] _ roles:SetRoleList { return { kind: 'defaultRole', roles }; }
+  / "DEFAULT"i ![a-zA-Z0-9_] _ "DATABASE"i ![a-zA-Z0-9_] _ db:AliasName { return { kind: 'defaultDatabase', database: db }; }
+  / "GRANTEES"i ![a-zA-Z0-9_] _ g:SetRoleList { return { kind: 'grantees', grantees: g }; }
+  / "VALID"i ![a-zA-Z0-9_] _ "UNTIL"i ![a-zA-Z0-9_] _ str:StringLiteral { return { kind: 'validUntil', value: str.value }; }
+
+AlterRoleStatement
+  = "ALTER"i ![a-zA-Z0-9_] _ "ROLE"i ![a-zA-Z0-9_]
+    ifExists:( _ "IF"i ![a-zA-Z0-9_] _ "EXISTS"i ![a-zA-Z0-9_] )?
+    _ names:CreateUserNameList
+    cluster:( _ OnClusterClause )?
+    rename:( _ "RENAME"i ![a-zA-Z0-9_] _ "TO"i ![a-zA-Z0-9_] _ CreateUserNameItem )?
+    settings:( _ CreateRoleSettingsClause )? {
+      const result = { kind: 'alterRole', names };
+      if (ifExists !== null) result.ifExists = true;
+      if (cluster !== null) result.onCluster = cluster[1];
+      if (rename !== null) result.renameTo = rename[7];
+      if (settings !== null) result.settings = settings[1];
+      return loc(result);
+    }
+
+AlterQuotaStatement
+  = "ALTER"i ![a-zA-Z0-9_] _ "QUOTA"i ![a-zA-Z0-9_]
+    ifExists:( _ "IF"i ![a-zA-Z0-9_] _ "EXISTS"i ![a-zA-Z0-9_] )?
+    _ names:QuotaNameList
+    cluster:( _ OnClusterClause )?
+    rename:( _ "RENAME"i ![a-zA-Z0-9_] _ "TO"i ![a-zA-Z0-9_] _ AccessControlNameValue )?
+    clauses:( _ ","? _ QuotaClause )* {
+      const result = { kind: 'alterQuota', names };
+      if (ifExists !== null) result.ifExists = true;
+      if (cluster !== null) result.onCluster = cluster[1];
+      if (rename !== null) result.renameTo = rename[7];
+      const intervals = [];
+      for (const c of clauses) {
+        const clause = c[3];
+        if (clause.keyed !== undefined) result.keyed = clause.keyed;
+        if (clause.interval !== undefined) intervals.push(clause.interval);
+        if (clause.to !== undefined) result.to = clause.to;
+      }
+      if (intervals.length > 0) result.intervals = intervals;
+      return loc(result);
+    }
+
+AlterRowPolicyStatement
+  = "ALTER"i ![a-zA-Z0-9_] _ hasRow:( "ROW"i ![a-zA-Z0-9_] _ )? "POLICY"i ![a-zA-Z0-9_]
+    ifExists:( _ "IF"i ![a-zA-Z0-9_] _ "EXISTS"i ![a-zA-Z0-9_] )?
+    _ targetsResult:RowPolicyTargets
+    clauses:( _ AlterRowPolicyClause )* {
+      const result = { kind: 'alterRowPolicy', targets: targetsResult.targets };
+      if (hasRow !== null) result.hasRowKeyword = true;
+      if (ifExists !== null) result.ifExists = true;
+      if (targetsResult.onCluster) result.onCluster = targetsResult.onCluster;
+      for (const c of clauses) {
+        const clause = c[1];
+        if (clause.renameTo !== undefined) result.renameTo = clause.renameTo;
+        if (clause.forSelect !== undefined) result.forSelect = clause.forSelect;
+        if (clause.using !== undefined) result.using = clause.using;
+        if (clause.restrictive !== undefined) result.restrictive = clause.restrictive;
+        if (clause.to !== undefined) result.to = clause.to;
+        if (clause.onCluster !== undefined) result.onCluster = clause.onCluster;
+      }
+      return loc(result);
+    }
+
+AlterRowPolicyClause
+  = "RENAME"i ![a-zA-Z0-9_] _ "TO"i ![a-zA-Z0-9_] _ name:AccessControlNameValue { return { renameTo: name }; }
+  / "FOR"i ![a-zA-Z0-9_] _ "SELECT"i ![a-zA-Z0-9_] { return { forSelect: true }; }
+  / "USING"i ![a-zA-Z0-9_] _ expr:Expression { return { using: expr }; }
+  / "AS"i ![a-zA-Z0-9_] _ mode:( "RESTRICTIVE"i / "PERMISSIVE"i ) ![a-zA-Z0-9_] { return { restrictive: mode.toUpperCase() }; }
+  / "TO"i ![a-zA-Z0-9_] _ target:SetRoleList { return { to: target }; }
+  / "ON"i ![a-zA-Z0-9_] _ "CLUSTER"i ![a-zA-Z0-9_] _ name:( StringLiteral { return text(); } / AliasName ) { return { onCluster: name }; }
+
+AlterSettingsProfileStatement
+  = "ALTER"i ![a-zA-Z0-9_] _ hasSK:( "SETTINGS"i ![a-zA-Z0-9_] _ )? "PROFILE"i ![a-zA-Z0-9_]
+    ifExists:( _ "IF"i ![a-zA-Z0-9_] _ "EXISTS"i ![a-zA-Z0-9_] )?
+    _ names:QuotaNameList
+    cluster:( _ OnClusterClause )?
+    rename:( _ "RENAME"i ![a-zA-Z0-9_] _ "TO"i ![a-zA-Z0-9_] _ AccessControlNameValue )?
+    settings:( _ CreateRoleSettingsClause )?
+    to:( _ "TO"i ![a-zA-Z0-9_] _ SetRoleList )? {
+      const result = { kind: 'alterSettingsProfile', names };
+      if (hasSK !== null) result.hasSettingsKeyword = true;
+      if (ifExists !== null) result.ifExists = true;
+      if (cluster !== null) result.onCluster = cluster[1];
+      if (rename !== null) result.renameTo = rename[7];
+      if (settings !== null) result.settings = settings[1];
+      if (to !== null) result.to = to[4];
+      return loc(result);
+    }
+
+// ── SHOW statements ──────────────────────────────────────────────────────────
+// SHOW CREATE TABLE/VIEW/DICTIONARY/DATABASE is handled by ShowCreateStatement;
+// this rule handles all other SHOW forms (including SHOW CREATE access entities).
+ShowStatement
+  = "SHOW"i ![a-zA-Z0-9_] _ show:ShowBody format:( _ FormatClause )? {
+      const result = { kind: 'show', show };
+      if (format !== null) result.format = format[1];
+      return loc(result);
+    }
+
+ShowBody
+  = ShowCreateAccessBody
+  / ShowColumnsBody
+  / ShowIndexesBody
+  / ShowGrantsBody
+  / ShowListingBody
+  / ShowAccessEntitiesBody
+  / ShowSettingBody
+  / ShowSimpleBody
+  / ShowClusterBody
+  / ShowObjectShorthandBody
+
+ShowCreateAccessBody
+  = "CREATE"i ![a-zA-Z0-9_] _ ShowRowPolicyKeyword _ targets:RowPolicyTargets {
+      return { type: 'createRowPolicy', policies: targets.targets };
+    }
+  / "CREATE"i ![a-zA-Z0-9_] _ ShowRowPolicyKeyword _ names:RowPolicyNameList {
+      return { type: 'createRowPolicy', policies: names.map(name => ({ names: [name] })) };
+    }
+  / "CREATE"i ![a-zA-Z0-9_] _ entity:ShowCreateAccessKeyword _ names:CreateUserNameList {
+      return { type: 'createAccess', entity, names };
+    }
+
+ShowRowPolicyKeyword
+  = "ROW"i ![a-zA-Z0-9_] _ ( "POLICIES"i / "POLICY"i ) ![a-zA-Z0-9_]
+  / ( "POLICIES"i / "POLICY"i ) ![a-zA-Z0-9_]
+
+ShowCreateAccessKeyword
+  = ( "USERS"i / "USER"i ) ![a-zA-Z0-9_] { return 'USER'; }
+  / ( "ROLES"i / "ROLE"i ) ![a-zA-Z0-9_] { return 'ROLE'; }
+  / ( "QUOTAS"i / "QUOTA"i ) ![a-zA-Z0-9_] { return 'QUOTA'; }
+  / ( "SETTINGS"i ![a-zA-Z0-9_] _ )? ( "PROFILES"i / "PROFILE"i ) ![a-zA-Z0-9_] { return 'SETTINGS PROFILE'; }
+  / "NAMED"i ![a-zA-Z0-9_] _ ( "COLLECTIONS"i / "COLLECTION"i ) ![a-zA-Z0-9_] { return 'NAMED COLLECTION'; }
+
+ShowColumnsBody
+  = extended:( "EXTENDED"i ![a-zA-Z0-9_] _ )? full:( "FULL"i ![a-zA-Z0-9_] _ )?
+    kw:( "COLUMNS"i { return 'COLUMNS'; } / "FIELDS"i { return 'FIELDS'; } ) ![a-zA-Z0-9_]
+    _ ( "FROM"i / "IN"i ) ![a-zA-Z0-9_] _ table:TableRef
+    from:( _ ( "FROM"i / "IN"i ) ![a-zA-Z0-9_] _ ( QueryParamIdentifier / AliasName ) )?
+    like:( _ ShowLikeClause )?
+    where:( _ "WHERE"i ![a-zA-Z0-9_] _ Expression )?
+    limit:( _ "LIMIT"i ![a-zA-Z0-9_] _ Expression )? {
+      const result = { type: 'columns', keyword: kw, table };
+      if (extended !== null) result.extended = true;
+      if (full !== null) result.full = true;
+      if (from !== null) result.from = from[4];
+      if (like !== null) result.like = like[1];
+      if (where !== null) result.where = where[4];
+      if (limit !== null) result.limit = limit[4];
+      return result;
+    }
+
+ShowIndexesBody
+  = extended:( "EXTENDED"i ![a-zA-Z0-9_] _ )?
+    kw:( "INDEXES"i { return 'INDEXES'; } / "INDICES"i { return 'INDICES'; } / "INDEX"i { return 'INDEX'; } / "KEYS"i { return 'KEYS'; } ) ![a-zA-Z0-9_]
+    _ ( "FROM"i / "IN"i ) ![a-zA-Z0-9_] _ table:TableRef
+    from:( _ ( "FROM"i / "IN"i ) ![a-zA-Z0-9_] _ ( QueryParamIdentifier / AliasName ) )?
+    where:( _ "WHERE"i ![a-zA-Z0-9_] _ Expression )? {
+      const result = { type: 'indexes', keyword: kw, table };
+      if (extended !== null) result.extended = true;
+      if (from !== null) result.from = from[4];
+      if (where !== null) result.where = where[4];
+      return result;
+    }
+
+ShowGrantsBody
+  = "GRANTS"i ![a-zA-Z0-9_]
+    forClause:( _ "FOR"i ![a-zA-Z0-9_] _ GranteeList )?
+    impl:( _ "WITH"i ![a-zA-Z0-9_] _ "IMPLICIT"i ![a-zA-Z0-9_] )?
+    final:( _ "FINAL"i ![a-zA-Z0-9_] )? {
+      const result = { type: 'grants' };
+      if (forClause !== null) result.for = forClause[4];
+      if (impl !== null) result.withImplicit = true;
+      if (final !== null) result.final = true;
+      return result;
+    }
+
+ShowListingBody
+  = temp:( "TEMPORARY"i ![a-zA-Z0-9_] _ )?
+    objectType:( "TABLES"i { return 'TABLES'; } / "DATABASES"i { return 'DATABASES'; } / "DICTIONARIES"i { return 'DICTIONARIES'; } ) ![a-zA-Z0-9_]
+    from:( _ ( "FROM"i / "IN"i ) ![a-zA-Z0-9_] _ ( QueryParamIdentifier / AliasName ) )?
+    like:( _ ShowLikeClause )?
+    where:( _ "WHERE"i ![a-zA-Z0-9_] _ Expression )?
+    limit:( _ "LIMIT"i ![a-zA-Z0-9_] _ Expression )?
+    settings:( _ SettingsClause )? {
+      const result = { type: 'listing', objectType };
+      if (temp !== null) result.temporary = true;
+      if (from !== null) result.from = from[4];
+      if (like !== null) result.like = like[1];
+      if (where !== null) result.where = where[4];
+      if (limit !== null) result.limit = limit[4];
+      if (settings !== null) result.settings = settings[1];
+      return result;
+    }
+
+ShowAccessEntitiesBody
+  = changedPre:( "CHANGED"i ![a-zA-Z0-9_] _ )? "SETTINGS"i ![a-zA-Z0-9_] _ "PROFILES"i ![a-zA-Z0-9_] {
+      return { type: 'accessEntities', objectType: 'SETTINGS PROFILES' };
+    }
+  / changedPre:( "CHANGED"i ![a-zA-Z0-9_] _ )? "SETTINGS"i ![a-zA-Z0-9_] like:( _ ShowLikeClause )? changedPost:( _ "CHANGED"i ![a-zA-Z0-9_] )? {
+      const result = { type: 'accessEntities', objectType: 'SETTINGS' };
+      if (changedPre !== null || changedPost !== null) result.modifier = 'CHANGED';
+      if (like !== null) result.like = like[1];
+      return result;
+    }
+  / "ROW"i ![a-zA-Z0-9_] _ "POLICIES"i ![a-zA-Z0-9_] { return { type: 'accessEntities', objectType: 'ROW POLICIES' }; }
+  / "POLICIES"i ![a-zA-Z0-9_] { return { type: 'accessEntities', objectType: 'ROW POLICIES' }; }
+  / "NAMED"i ![a-zA-Z0-9_] _ "COLLECTIONS"i ![a-zA-Z0-9_] { return { type: 'accessEntities', objectType: 'NAMED COLLECTIONS' }; }
+  / "PROFILES"i ![a-zA-Z0-9_] { return { type: 'accessEntities', objectType: 'SETTINGS PROFILES' }; }
+  / "CLUSTERS"i ![a-zA-Z0-9_] like:( _ ShowLikeClause )? limit:( _ "LIMIT"i ![a-zA-Z0-9_] _ Expression )? {
+      const result = { type: 'accessEntities', objectType: 'CLUSTERS' };
+      if (like !== null) result.like = like[1];
+      if (limit !== null) result.limit = limit[4];
+      return result;
+    }
+  / mod:( ( "CURRENT"i / "ENABLED"i ) ![a-zA-Z0-9_] _ )? "ROLES"i ![a-zA-Z0-9_] {
+      const result = { type: 'accessEntities', objectType: 'ROLES' };
+      if (mod !== null) result.modifier = mod[0].toUpperCase();
+      return result;
+    }
+  / "USERS"i ![a-zA-Z0-9_] { return { type: 'accessEntities', objectType: 'USERS' }; }
+  / "QUOTAS"i ![a-zA-Z0-9_] { return { type: 'accessEntities', objectType: 'QUOTAS' }; }
+  / "WARNINGS"i ![a-zA-Z0-9_] { return { type: 'accessEntities', objectType: 'WARNINGS' }; }
+
+ShowSettingBody
+  = "SETTING"i ![a-zA-Z0-9_] _ name:( QueryParamIdentifier / AliasName ) { return { type: 'setting', name }; }
+
+ShowSimpleBody
+  = "PRIVILEGES"i ![a-zA-Z0-9_] { return { type: 'privileges' }; }
+  / "ENGINES"i ![a-zA-Z0-9_] { return { type: 'engines' }; }
+  / "MERGES"i ![a-zA-Z0-9_] { return { type: 'merges' }; }
+  / "ACCESS"i ![a-zA-Z0-9_] { return { type: 'access' }; }
+  / full:( "FULL"i ![a-zA-Z0-9_] _ )? "PROCESSLIST"i ![a-zA-Z0-9_] {
+      const result = { type: 'processlist' };
+      if (full !== null) result.full = true;
+      return result;
+    }
+  / "FUNCTIONS"i ![a-zA-Z0-9_] like:( _ ShowLikeClause )? {
+      const result = { type: 'functions' };
+      if (like !== null) result.like = like[1];
+      return result;
+    }
+
+ShowClusterBody
+  = "CLUSTER"i ![a-zA-Z0-9_] _ name:( QueryParamIdentifier / AliasName ) { return { type: 'cluster', name }; }
+
+ShowObjectShorthandBody
+  = temp:( "TEMPORARY"i ![a-zA-Z0-9_] _ )? kw:( "TABLE"i { return 'TABLE'; } / "VIEW"i { return 'VIEW'; } ) ![a-zA-Z0-9_] _ table:TableRef {
+      const result = { type: 'objectShorthand', objectType: kw, table };
+      if (temp !== null) result.temporary = true;
+      return result;
+    }
+  / "DATABASE"i ![a-zA-Z0-9_] _ db:( QueryParamIdentifier / AliasName ) { return { type: 'databaseShorthand', database: db }; }
+
+ShowLikeClause
+  = not:( "NOT"i ![a-zA-Z0-9_] _ )? kw:( "ILIKE"i { return true; } / "LIKE"i { return false; } ) ![a-zA-Z0-9_] _ pat:StringLiteral {
+      const result = { pattern: pat.value };
+      if (not !== null) result.not = true;
+      if (kw) result.ilike = true;
+      return result;
+    }
+
 DropTargetType
   = "TABLE"i ![a-zA-Z0-9_] { return 'TABLE'; }
   / "VIEW"i ![a-zA-Z0-9_] { return 'VIEW'; }
@@ -988,6 +1453,8 @@ ParallelWithStatement
 ParallelWithItem
   = InsertStatement
   / DropStatement
+  / UndropStatement
+  / BackupStatement
   / TruncateStatement
   / OptimizeStatement
   / AlterStatement
@@ -1145,8 +1612,9 @@ ShowCreateTarget
       return { kind: 'showCreate', targetType: 'TABLE', table };
     }
 
-// Keywords that indicate SHOW CREATE targeting an access-control or other
-// object we don't yet parse structurally; these fall through to OpaqueStatement.
+// Keywords that indicate SHOW CREATE targeting an access-control object; these
+// are excluded here so ShowStatement (which handles SHOW CREATE USER/ROLE/etc.)
+// can parse them structurally instead.
 ShowCreateAccessControlKeyword
   = "USER"i ![a-zA-Z0-9_]
   / "ROLE"i ![a-zA-Z0-9_]
@@ -1291,8 +1759,8 @@ CheckPartitionClause
 // ── ATTACH ───────────────────────────────────────────────────────────────────
 // ATTACH [TABLE|VIEW|DICTIONARY] [IF NOT EXISTS] [db.]name [UUID '...'] [ON CLUSTER ...]
 // ATTACH DATABASE [IF NOT EXISTS] name [ON CLUSTER ...]
-// Only matches SIMPLE ATTACH forms. Complex ATTACHes (ATTACH MATERIALIZED VIEW
-// with columns/ENGINE/AS SELECT) fall through to OpaqueStatement.
+// Only matches SIMPLE ATTACH forms. ATTACH MATERIALIZED VIEW (with columns/
+// ENGINE/AS SELECT) is handled by CreateMaterializedViewStatement.
 AttachStatement
   = "ATTACH"i ![a-zA-Z0-9_] _ "DATABASE"i ![a-zA-Z0-9_]
     ifne:( _ "IF"i ![a-zA-Z0-9_] _ "NOT"i ![a-zA-Z0-9_] _ "EXISTS"i ![a-zA-Z0-9_] )?
@@ -1794,10 +2262,12 @@ CreateUserAuthSecretValue
   / "{" body:$[^}]* "}" { return '{' + body + '}'; }
 
 CreateUserSSHKeyList
-  = head:CreateUserSSHKey tail:( _ "," _ CreateUserSSHKey )* { return 1 + tail.length; }
+  = head:CreateUserSSHKey tail:( _ "," _ CreateUserSSHKey )* { return [head, ...tail.map(t => t[3])]; }
 
 CreateUserSSHKey
-  = "KEY"i ![a-zA-Z0-9_] _ StringLiteral _ "TYPE"i ![a-zA-Z0-9_] _ StringLiteral
+  = "KEY"i ![a-zA-Z0-9_] _ key:StringLiteral _ "TYPE"i ![a-zA-Z0-9_] _ type:StringLiteral {
+      return { key: key.value, type: type.value };
+    }
 
 // ── HOST items ───────────────────────────────────────────────────────────────
 HostItemList
@@ -1814,8 +2284,8 @@ HostItems
   = "ANY"i ![a-zA-Z0-9_] { return { kind: 'any' }; }
   / "NONE"i ![a-zA-Z0-9_] { return { kind: 'none' }; }
   / "LOCAL"i ![a-zA-Z0-9_] { return { kind: 'local' }; }
-  / "NAME"i ![a-zA-Z0-9_] _ str:StringLiteral { return { kind: 'name', value: str.value }; }
-  / "REGEXP"i ![a-zA-Z0-9_] _ str:StringLiteral { return { kind: 'regexp', value: str.value }; }
+  / "NAME"i ![a-zA-Z0-9_] _ strs:HostStringList { return strs.map(s => ({ kind: 'name', value: s })); }
+  / "REGEXP"i ![a-zA-Z0-9_] _ strs:HostStringList { return strs.map(s => ({ kind: 'regexp', value: s })); }
   / "LIKE"i ![a-zA-Z0-9_] _ strs:HostStringList { return strs.map(s => ({ kind: 'like', value: s })); }
   / "IP"i ![a-zA-Z0-9_] _ strs:HostStringList { return strs.map(s => ({ kind: 'ip', value: s })); }
 
@@ -2142,7 +2612,7 @@ OnClusterClause
 
 // RefreshClause: REFRESH AFTER|EVERY N unit [APPEND]
 RefreshClause
-  = "REFRESH"i ![a-zA-Z0-9_] body:$( _ !("TO"i ![a-zA-Z0-9_] / "ENGINE"i ![a-zA-Z0-9_] / "(" / KW_AS / "EMPTY"i ![a-zA-Z0-9_] / "POPULATE"i ![a-zA-Z0-9_] / "ORDER"i ![a-zA-Z0-9_] / "PARTITION"i ![a-zA-Z0-9_] / "PRIMARY"i ![a-zA-Z0-9_] / "SAMPLE"i ![a-zA-Z0-9_] / "TTL"i ![a-zA-Z0-9_] / KW_SETTINGS / "COMMENT"i ![a-zA-Z0-9_]) . )+ {
+  = "REFRESH"i ![a-zA-Z0-9_] body:$( _ !(";" / "TO"i ![a-zA-Z0-9_] / "ENGINE"i ![a-zA-Z0-9_] / "(" / KW_AS / "EMPTY"i ![a-zA-Z0-9_] / "POPULATE"i ![a-zA-Z0-9_] / "ORDER"i ![a-zA-Z0-9_] / "PARTITION"i ![a-zA-Z0-9_] / "PRIMARY"i ![a-zA-Z0-9_] / "SAMPLE"i ![a-zA-Z0-9_] / "TTL"i ![a-zA-Z0-9_] / KW_SETTINGS / "COMMENT"i ![a-zA-Z0-9_] / "FORMAT"i ![a-zA-Z0-9_]) . )+ {
       return body.trim();
     }
 
@@ -2564,6 +3034,8 @@ ExplainInnerStatement
   / SystemStatement
   / InsertStatement
   / DropStatement
+  / UndropStatement
+  / BackupStatement
   / TruncateStatement
   / OptimizeStatement
   / DescribeStatement
diff --git a/src/parser.js b/src/parser.js
index bdc83a4ca..07c417f60 100644
--- a/src/parser.js
+++ b/src/parser.js
@@ -257,424 +257,451 @@ function peg$parse(input, options) {
   const peg$c12 = "all";
   const peg$c13 = "except";
   const peg$c14 = "none";
-  const peg$c15 = ",";
-  const peg$c16 = "use";
-  const peg$c17 = "system";
-  const peg$c18 = "alter";
-  const peg$c19 = "temporary";
-  const peg$c20 = "table";
-  const peg$c21 = "(";
-  const peg$c22 = ")";
-  const peg$c23 = "add";
-  const peg$c24 = "column";
-  const peg$c25 = "if";
-  const peg$c26 = "not";
-  const peg$c27 = "exists";
-  const peg$c28 = "after";
-  const peg$c29 = "first";
-  const peg$c30 = "drop";
-  const peg$c31 = "clear";
-  const peg$c32 = "modify";
-  const peg$c33 = "type";
-  const peg$c34 = "remove";
-  const peg$c35 = ".";
-  const peg$c36 = "materialized";
-  const peg$c37 = "ephemeral";
-  const peg$c38 = "alias";
-  const peg$c39 = "comment";
-  const peg$c40 = "codec";
-  const peg$c41 = "ttl";
-  const peg$c42 = "statistics";
-  const peg$c43 = "settings";
-  const peg$c44 = "null";
-  const peg$c45 = "reset";
-  const peg$c46 = "auto_increment";
-  const peg$c47 = "collate";
-  const peg$c48 = "primary";
-  const peg$c49 = "key";
-  const peg$c50 = "setting";
-  const peg$c51 = "rename";
-  const peg$c52 = "materialize";
-  const peg$c53 = "with";
-  const peg$c54 = "index";
-  const peg$c55 = "check";
-  const peg$c56 = "assume";
-  const peg$c57 = "granularity";
-  const peg$c58 = "projection";
-  const peg$c59 = "constraint";
-  const peg$c60 = "update";
-  const peg$c61 = "where";
-  const peg$c62 = "=";
-  const peg$c63 = "delete";
-  const peg$c64 = "detach";
-  const peg$c65 = "part";
-  const peg$c66 = "partition";
-  const peg$c67 = "detached";
-  const peg$c68 = "attach";
-  const peg$c69 = "from";
-  const peg$c70 = "replace";
-  const peg$c71 = "move";
-  const peg$c72 = "disk";
-  const peg$c73 = "volume";
-  const peg$c74 = "shard";
-  const peg$c75 = "fetch";
-  const peg$c76 = "id";
-  const peg$c77 = "freeze";
-  const peg$c78 = "name";
-  const peg$c79 = "order";
-  const peg$c80 = "by";
-  const peg$c81 = "sample";
-  const peg$c82 = "query";
-  const peg$c83 = "apply";
-  const peg$c84 = "deleted";
-  const peg$c85 = "mask";
-  const peg$c86 = "patches";
-  const peg$c87 = "rewrite";
-  const peg$c88 = "parts";
-  const peg$c89 = "in";
-  const peg$c90 = "exchange";
-  const peg$c91 = "show";
-  const peg$c92 = "grant";
-  const peg$c93 = "revoke";
-  const peg$c94 = "kill";
-  const peg$c95 = "undo";
-  const peg$c96 = "backup";
-  const peg$c97 = "restore";
-  const peg$c98 = "begin";
-  const peg$c99 = "commit";
-  const peg$c100 = "rollback";
-  const peg$c101 = "watch";
-  const peg$c102 = "undrop";
-  const peg$c103 = "on";
-  const peg$c104 = "empty";
-  const peg$c105 = "sync";
-  const peg$c106 = "no";
-  const peg$c107 = "delay";
-  const peg$c108 = "'";
-  const peg$c109 = "''";
-  const peg$c110 = "\\'";
-  const peg$c111 = "\\\\";
-  const peg$c112 = "view";
-  const peg$c113 = "dictionary";
-  const peg$c114 = "database";
-  const peg$c115 = "function";
-  const peg$c116 = "insert";
-  const peg$c117 = "infile";
-  const peg$c118 = "compression";
-  const peg$c119 = "values";
-  const peg$c120 = "format";
-  const peg$c121 = "parallel";
-  const peg$c122 = "tables";
-  const peg$c123 = "like";
-  const peg$c124 = "optimize";
-  const peg$c125 = "final";
-  const peg$c126 = "force";
-  const peg$c127 = "cleanup";
-  const peg$c128 = "deduplicate";
-  const peg$c129 = "describe";
-  const peg$c130 = "desc";
-  const peg$c131 = "select";
-  const peg$c132 = "create";
-  const peg$c133 = "user";
-  const peg$c134 = "quota";
-  const peg$c135 = "row";
-  const peg$c136 = "policy";
-  const peg$c137 = "profile";
-  const peg$c138 = "named";
-  const peg$c139 = "collection";
-  const peg$c140 = "workload";
-  const peg$c141 = "resource";
-  const peg$c142 = "permanently";
-  const peg$c143 = "uuid";
-  const peg$c144 = "dictionaries";
-  const peg$c145 = "and";
-  const peg$c146 = "mutation";
-  const peg$c147 = "async";
-  const peg$c148 = "test";
-  const peg$c149 = "or";
-  const peg$c150 = "inner";
-  const peg$c151 = "populate";
-  const peg$c152 = "unique";
-  const peg$c153 = "expression";
-  const peg$c154 = "injective";
-  const peg$c155 = "is_object_id";
-  const peg$c156 = "hierarchical";
-  const peg$c157 = "bidirectional";
-  const peg$c158 = "source";
-  const peg$c159 = "lifetime";
-  const peg$c160 = "layout";
-  const peg$c161 = "range";
-  const peg$c162 = "min";
-  const peg$c163 = "max";
-  const peg$c164 = "asc";
-  const peg$c165 = "identified";
-  const peg$c166 = "host";
-  const peg$c167 = "grantees";
-  const peg$c168 = "valid";
-  const peg$c169 = "until";
-  const peg$c170 = "cluster";
-  const peg$c171 = "@";
-  const peg$c172 = "{";
-  const peg$c173 = "}";
-  const peg$c174 = "ssh_key";
-  const peg$c175 = "realm";
-  const peg$c176 = "server";
-  const peg$c177 = "any";
-  const peg$c178 = "local";
-  const peg$c179 = "regexp";
-  const peg$c180 = "ip";
-  const peg$c181 = "inherit";
-  const peg$c182 = "const";
-  const peg$c183 = "writable";
-  const peg$c184 = "readonly";
-  const peg$c185 = "*";
-  const peg$c186 = "for";
-  const peg$c187 = "using";
-  const peg$c188 = "restrictive";
-  const peg$c189 = "permissive";
-  const peg$c190 = "keyed";
-  const peg$c191 = "randomized";
-  const peg$c192 = "interval";
-  const peg$c193 = "second";
-  const peg$c194 = "minute";
-  const peg$c195 = "hour";
-  const peg$c196 = "day";
-  const peg$c197 = "week";
-  const peg$c198 = "month";
-  const peg$c199 = "quarter";
-  const peg$c200 = "year";
-  const peg$c201 = "s";
-  const peg$c202 = "tracking";
-  const peg$c203 = "only";
-  const peg$c204 = "limits";
-  const peg$c205 = "result";
-  const peg$c206 = "read";
-  const peg$c207 = "execution";
-  const peg$c208 = " ";
-  const peg$c209 = "rows";
-  const peg$c210 = "bytes";
-  const peg$c211 = "time";
-  const peg$c212 = "_";
-  const peg$c213 = "write";
-  const peg$c214 = "window";
-  const peg$c215 = "live";
-  const peg$c216 = "refresh";
-  const peg$c217 = "engine";
-  const peg$c218 = "clone";
-  const peg$c219 = "`";
-  const peg$c220 = "foreign";
-  const peg$c221 = "references";
-  const peg$c222 = "cascade";
-  const peg$c223 = "restrict";
-  const peg$c224 = "action";
-  const peg$c225 = "recompress";
-  const peg$c226 = "group";
-  const peg$c227 = "explain";
-  const peg$c228 = "tree";
-  const peg$c229 = "override";
-  const peg$c230 = "current";
-  const peg$c231 = "ast";
-  const peg$c232 = "syntax";
-  const peg$c233 = "plan";
-  const peg$c234 = "pipeline";
-  const peg$c235 = "estimate";
-  const peg$c236 = "intersect";
-  const peg$c237 = "distinct";
-  const peg$c238 = "top";
-  const peg$c239 = "ties";
-  const peg$c240 = "recursive";
-  const peg$c241 = "->";
-  const peg$c242 = "prewhere";
-  const peg$c243 = "having";
-  const peg$c244 = "limit";
-  const peg$c245 = "offset";
-  const peg$c246 = "union";
-  const peg$c247 = "/";
-  const peg$c248 = "paste";
-  const peg$c249 = "grouping";
-  const peg$c250 = "sets";
-  const peg$c251 = "rollup";
-  const peg$c252 = "cube";
-  const peg$c253 = "qualify";
-  const peg$c254 = "next";
-  const peg$c255 = "\"";
-  const peg$c256 = "nulls";
-  const peg$c257 = "last";
-  const peg$c258 = "fill";
-  const peg$c259 = "step";
-  const peg$c260 = "staleness";
-  const peg$c261 = "interpolate";
-  const peg$c262 = "?";
-  const peg$c263 = ":";
-  const peg$c264 = "::";
-  const peg$c265 = "is";
-  const peg$c266 = "<=>";
-  const peg$c267 = ">=";
-  const peg$c268 = "<=";
-  const peg$c269 = "<>";
-  const peg$c270 = "!=";
-  const peg$c271 = "==";
-  const peg$c272 = "+";
-  const peg$c273 = "-";
-  const peg$c274 = ">";
-  const peg$c275 = "\u2212";
-  const peg$c276 = "||";
-  const peg$c277 = "div";
-  const peg$c278 = "mod";
-  const peg$c279 = "respect";
-  const peg$c280 = "ignore";
-  const peg$c281 = "over";
-  const peg$c282 = "between";
-  const peg$c283 = "groups";
-  const peg$c284 = "unbounded";
-  const peg$c285 = "preceding";
-  const peg$c286 = "following";
-  const peg$c287 = "[";
-  const peg$c288 = "]";
-  const peg$c289 = "double";
-  const peg$c290 = "precision";
-  const peg$c291 = "national";
-  const peg$c292 = "character";
-  const peg$c293 = "char";
-  const peg$c294 = "large";
-  const peg$c295 = "object";
-  const peg$c296 = "varying";
-  const peg$c297 = "nchar";
-  const peg$c298 = "binary";
-  const peg$c299 = "int1";
-  const peg$c300 = "signed";
-  const peg$c301 = "unsigned";
-  const peg$c302 = "tinyint";
-  const peg$c303 = "smallint";
-  const peg$c304 = "bigint";
-  const peg$c305 = "mediumint";
-  const peg$c306 = "integer";
-  const peg$c307 = "int";
-  const peg$c308 = "enum8";
-  const peg$c309 = "enum16";
-  const peg$c310 = "enum";
-  const peg$c311 = "skip";
-  const peg$c312 = "@@";
-  const peg$c313 = "session.";
-  const peg$c314 = "global.";
-  const peg$c315 = "local.";
-  const peg$c316 = "$";
-  const peg$c317 = "true";
-  const peg$c318 = "false";
-  const peg$c319 = "0x";
-  const peg$c320 = "0b";
-  const peg$c321 = "inf";
-  const peg$c322 = "nan";
-  const peg$c323 = "case";
-  const peg$c324 = "else";
-  const peg$c325 = "end";
-  const peg$c326 = "when";
-  const peg$c327 = "then";
-  const peg$c328 = "date_add";
-  const peg$c329 = "dateadd";
-  const peg$c330 = "timestamp_add";
-  const peg$c331 = "timestampadd";
-  const peg$c332 = "date_sub";
-  const peg$c333 = "datesub";
-  const peg$c334 = "timestamp_sub";
-  const peg$c335 = "timestampsub";
-  const peg$c336 = "datediff";
-  const peg$c337 = "date_diff";
-  const peg$c338 = "substring";
-  const peg$c339 = "substr";
-  const peg$c340 = "mid";
-  const peg$c341 = "extract";
-  const peg$c342 = "trim";
-  const peg$c343 = "position";
-  const peg$c344 = "date";
-  const peg$c345 = "timestamp";
-  const peg$c346 = "cast";
-  const peg$c347 = "leading";
-  const peg$c348 = "trailing";
-  const peg$c349 = "both";
-  const peg$c350 = "filter";
-  const peg$c351 = "^";
-  const peg$c352 = "[]";
-  const peg$c353 = "strict";
-  const peg$c354 = "columns";
-  const peg$c355 = "\u2018";
-  const peg$c356 = "\u2019";
-  const peg$c357 = "\\a";
-  const peg$c358 = "\\e";
-  const peg$c359 = "\\v";
-  const peg$c360 = "\\b";
-  const peg$c361 = "\\f";
-  const peg$c362 = "\\n";
-  const peg$c363 = "\\r";
-  const peg$c364 = "\\t";
-  const peg$c365 = "\\0";
-  const peg$c366 = "\\\"";
-  const peg$c367 = "\\x";
-  const peg$c368 = "\\";
-  const peg$c369 = "identifier";
-  const peg$c370 = "\u201C";
-  const peg$c371 = "\u201D";
-  const peg$c372 = "\"\"";
-  const peg$c373 = "``";
-  const peg$c374 = "join";
-  const peg$c375 = "left";
-  const peg$c376 = "right";
-  const peg$c377 = "full";
-  const peg$c378 = "cross";
-  const peg$c379 = "outer";
-  const peg$c380 = "array";
-  const peg$c381 = "totals";
-  const peg$c382 = "semi";
-  const peg$c383 = "anti";
-  const peg$c384 = "asof";
-  const peg$c385 = "global";
-  const peg$c386 = "ilike";
-  const peg$c387 = "--";
-  const peg$c388 = "#!";
-  const peg$c389 = "# ";
-  const peg$c390 = "//";
-  const peg$c391 = "/*";
-  const peg$c392 = "*/";
+  const peg$c15 = "begin";
+  const peg$c16 = "start";
+  const peg$c17 = "commit";
+  const peg$c18 = "rollback";
+  const peg$c19 = "use";
+  const peg$c20 = "system";
+  const peg$c21 = "alter";
+  const peg$c22 = "temporary";
+  const peg$c23 = "table";
+  const peg$c24 = ",";
+  const peg$c25 = "(";
+  const peg$c26 = ")";
+  const peg$c27 = "add";
+  const peg$c28 = "column";
+  const peg$c29 = "if";
+  const peg$c30 = "not";
+  const peg$c31 = "exists";
+  const peg$c32 = "after";
+  const peg$c33 = "first";
+  const peg$c34 = "drop";
+  const peg$c35 = "clear";
+  const peg$c36 = "modify";
+  const peg$c37 = "type";
+  const peg$c38 = "remove";
+  const peg$c39 = ".";
+  const peg$c40 = "materialized";
+  const peg$c41 = "ephemeral";
+  const peg$c42 = "alias";
+  const peg$c43 = "comment";
+  const peg$c44 = "codec";
+  const peg$c45 = "ttl";
+  const peg$c46 = "statistics";
+  const peg$c47 = "settings";
+  const peg$c48 = "null";
+  const peg$c49 = "reset";
+  const peg$c50 = "auto_increment";
+  const peg$c51 = "collate";
+  const peg$c52 = "primary";
+  const peg$c53 = "key";
+  const peg$c54 = "setting";
+  const peg$c55 = "rename";
+  const peg$c56 = "materialize";
+  const peg$c57 = "with";
+  const peg$c58 = "index";
+  const peg$c59 = "check";
+  const peg$c60 = "assume";
+  const peg$c61 = "granularity";
+  const peg$c62 = "projection";
+  const peg$c63 = "constraint";
+  const peg$c64 = "update";
+  const peg$c65 = "where";
+  const peg$c66 = "=";
+  const peg$c67 = "delete";
+  const peg$c68 = "detach";
+  const peg$c69 = "part";
+  const peg$c70 = "partition";
+  const peg$c71 = "detached";
+  const peg$c72 = "attach";
+  const peg$c73 = "from";
+  const peg$c74 = "replace";
+  const peg$c75 = "move";
+  const peg$c76 = "disk";
+  const peg$c77 = "volume";
+  const peg$c78 = "shard";
+  const peg$c79 = "fetch";
+  const peg$c80 = "id";
+  const peg$c81 = "freeze";
+  const peg$c82 = "name";
+  const peg$c83 = "order";
+  const peg$c84 = "by";
+  const peg$c85 = "sample";
+  const peg$c86 = "query";
+  const peg$c87 = "apply";
+  const peg$c88 = "deleted";
+  const peg$c89 = "mask";
+  const peg$c90 = "patches";
+  const peg$c91 = "rewrite";
+  const peg$c92 = "parts";
+  const peg$c93 = "in";
+  const peg$c94 = "on";
+  const peg$c95 = "empty";
+  const peg$c96 = "sync";
+  const peg$c97 = "no";
+  const peg$c98 = "delay";
+  const peg$c99 = "'";
+  const peg$c100 = "''";
+  const peg$c101 = "\\'";
+  const peg$c102 = "\\\\";
+  const peg$c103 = "undrop";
+  const peg$c104 = "uuid";
+  const peg$c105 = "backup";
+  const peg$c106 = "restore";
+  const peg$c107 = "async";
+  const peg$c108 = "databases";
+  const peg$c109 = "tables";
+  const peg$c110 = "dictionary";
+  const peg$c111 = "view";
+  const peg$c112 = "database";
+  const peg$c113 = "function";
+  const peg$c114 = "named";
+  const peg$c115 = "collection";
+  const peg$c116 = "partitions";
+  const peg$c117 = "columns";
+  const peg$c118 = "grant";
+  const peg$c119 = "revoke";
+  const peg$c120 = "admin";
+  const peg$c121 = "option";
+  const peg$c122 = "for";
+  const peg$c123 = "*";
+  const peg$c124 = "`";
+  const peg$c125 = "current_user";
+  const peg$c126 = "user";
+  const peg$c127 = "identified";
+  const peg$c128 = "host";
+  const peg$c129 = "grantees";
+  const peg$c130 = "valid";
+  const peg$c131 = "until";
+  const peg$c132 = "quota";
+  const peg$c133 = "row";
+  const peg$c134 = "policy";
+  const peg$c135 = "select";
+  const peg$c136 = "using";
+  const peg$c137 = "restrictive";
+  const peg$c138 = "permissive";
+  const peg$c139 = "cluster";
+  const peg$c140 = "profile";
+  const peg$c141 = "show";
+  const peg$c142 = "create";
+  const peg$c143 = "policies";
+  const peg$c144 = "users";
+  const peg$c145 = "roles";
+  const peg$c146 = "quotas";
+  const peg$c147 = "profiles";
+  const peg$c148 = "collections";
+  const peg$c149 = "extended";
+  const peg$c150 = "full";
+  const peg$c151 = "fields";
+  const peg$c152 = "limit";
+  const peg$c153 = "indexes";
+  const peg$c154 = "indices";
+  const peg$c155 = "keys";
+  const peg$c156 = "grants";
+  const peg$c157 = "implicit";
+  const peg$c158 = "final";
+  const peg$c159 = "dictionaries";
+  const peg$c160 = "changed";
+  const peg$c161 = "clusters";
+  const peg$c162 = "current";
+  const peg$c163 = "enabled";
+  const peg$c164 = "warnings";
+  const peg$c165 = "privileges";
+  const peg$c166 = "engines";
+  const peg$c167 = "merges";
+  const peg$c168 = "access";
+  const peg$c169 = "processlist";
+  const peg$c170 = "functions";
+  const peg$c171 = "ilike";
+  const peg$c172 = "like";
+  const peg$c173 = "insert";
+  const peg$c174 = "infile";
+  const peg$c175 = "compression";
+  const peg$c176 = "values";
+  const peg$c177 = "format";
+  const peg$c178 = "parallel";
+  const peg$c179 = "optimize";
+  const peg$c180 = "force";
+  const peg$c181 = "cleanup";
+  const peg$c182 = "deduplicate";
+  const peg$c183 = "describe";
+  const peg$c184 = "desc";
+  const peg$c185 = "workload";
+  const peg$c186 = "resource";
+  const peg$c187 = "permanently";
+  const peg$c188 = "exchange";
+  const peg$c189 = "and";
+  const peg$c190 = "kill";
+  const peg$c191 = "mutation";
+  const peg$c192 = "test";
+  const peg$c193 = "or";
+  const peg$c194 = "inner";
+  const peg$c195 = "populate";
+  const peg$c196 = "unique";
+  const peg$c197 = "expression";
+  const peg$c198 = "injective";
+  const peg$c199 = "is_object_id";
+  const peg$c200 = "hierarchical";
+  const peg$c201 = "bidirectional";
+  const peg$c202 = "source";
+  const peg$c203 = "lifetime";
+  const peg$c204 = "layout";
+  const peg$c205 = "range";
+  const peg$c206 = "min";
+  const peg$c207 = "max";
+  const peg$c208 = "asc";
+  const peg$c209 = "@";
+  const peg$c210 = "{";
+  const peg$c211 = "}";
+  const peg$c212 = "ssh_key";
+  const peg$c213 = "realm";
+  const peg$c214 = "server";
+  const peg$c215 = "any";
+  const peg$c216 = "local";
+  const peg$c217 = "regexp";
+  const peg$c218 = "ip";
+  const peg$c219 = "inherit";
+  const peg$c220 = "const";
+  const peg$c221 = "writable";
+  const peg$c222 = "readonly";
+  const peg$c223 = "keyed";
+  const peg$c224 = "randomized";
+  const peg$c225 = "interval";
+  const peg$c226 = "second";
+  const peg$c227 = "minute";
+  const peg$c228 = "hour";
+  const peg$c229 = "day";
+  const peg$c230 = "week";
+  const peg$c231 = "month";
+  const peg$c232 = "quarter";
+  const peg$c233 = "year";
+  const peg$c234 = "s";
+  const peg$c235 = "tracking";
+  const peg$c236 = "only";
+  const peg$c237 = "limits";
+  const peg$c238 = "result";
+  const peg$c239 = "read";
+  const peg$c240 = "execution";
+  const peg$c241 = " ";
+  const peg$c242 = "rows";
+  const peg$c243 = "bytes";
+  const peg$c244 = "time";
+  const peg$c245 = "_";
+  const peg$c246 = "write";
+  const peg$c247 = "window";
+  const peg$c248 = "live";
+  const peg$c249 = "refresh";
+  const peg$c250 = "engine";
+  const peg$c251 = "clone";
+  const peg$c252 = "foreign";
+  const peg$c253 = "references";
+  const peg$c254 = "cascade";
+  const peg$c255 = "restrict";
+  const peg$c256 = "action";
+  const peg$c257 = "recompress";
+  const peg$c258 = "group";
+  const peg$c259 = "explain";
+  const peg$c260 = "tree";
+  const peg$c261 = "override";
+  const peg$c262 = "ast";
+  const peg$c263 = "syntax";
+  const peg$c264 = "plan";
+  const peg$c265 = "pipeline";
+  const peg$c266 = "estimate";
+  const peg$c267 = "intersect";
+  const peg$c268 = "distinct";
+  const peg$c269 = "top";
+  const peg$c270 = "ties";
+  const peg$c271 = "recursive";
+  const peg$c272 = "->";
+  const peg$c273 = "prewhere";
+  const peg$c274 = "having";
+  const peg$c275 = "offset";
+  const peg$c276 = "union";
+  const peg$c277 = "/";
+  const peg$c278 = "paste";
+  const peg$c279 = "grouping";
+  const peg$c280 = "sets";
+  const peg$c281 = "rollup";
+  const peg$c282 = "cube";
+  const peg$c283 = "qualify";
+  const peg$c284 = "next";
+  const peg$c285 = "\"";
+  const peg$c286 = "nulls";
+  const peg$c287 = "last";
+  const peg$c288 = "fill";
+  const peg$c289 = "step";
+  const peg$c290 = "staleness";
+  const peg$c291 = "interpolate";
+  const peg$c292 = "?";
+  const peg$c293 = ":";
+  const peg$c294 = "::";
+  const peg$c295 = "is";
+  const peg$c296 = "<=>";
+  const peg$c297 = ">=";
+  const peg$c298 = "<=";
+  const peg$c299 = "<>";
+  const peg$c300 = "!=";
+  const peg$c301 = "==";
+  const peg$c302 = "+";
+  const peg$c303 = "-";
+  const peg$c304 = ">";
+  const peg$c305 = "\u2212";
+  const peg$c306 = "||";
+  const peg$c307 = "div";
+  const peg$c308 = "mod";
+  const peg$c309 = "respect";
+  const peg$c310 = "ignore";
+  const peg$c311 = "over";
+  const peg$c312 = "between";
+  const peg$c313 = "groups";
+  const peg$c314 = "unbounded";
+  const peg$c315 = "preceding";
+  const peg$c316 = "following";
+  const peg$c317 = "[";
+  const peg$c318 = "]";
+  const peg$c319 = "double";
+  const peg$c320 = "precision";
+  const peg$c321 = "national";
+  const peg$c322 = "character";
+  const peg$c323 = "char";
+  const peg$c324 = "large";
+  const peg$c325 = "object";
+  const peg$c326 = "varying";
+  const peg$c327 = "nchar";
+  const peg$c328 = "binary";
+  const peg$c329 = "int1";
+  const peg$c330 = "signed";
+  const peg$c331 = "unsigned";
+  const peg$c332 = "tinyint";
+  const peg$c333 = "smallint";
+  const peg$c334 = "bigint";
+  const peg$c335 = "mediumint";
+  const peg$c336 = "integer";
+  const peg$c337 = "int";
+  const peg$c338 = "enum8";
+  const peg$c339 = "enum16";
+  const peg$c340 = "enum";
+  const peg$c341 = "skip";
+  const peg$c342 = "@@";
+  const peg$c343 = "session.";
+  const peg$c344 = "global.";
+  const peg$c345 = "local.";
+  const peg$c346 = "$";
+  const peg$c347 = "true";
+  const peg$c348 = "false";
+  const peg$c349 = "0x";
+  const peg$c350 = "0b";
+  const peg$c351 = "inf";
+  const peg$c352 = "nan";
+  const peg$c353 = "case";
+  const peg$c354 = "else";
+  const peg$c355 = "end";
+  const peg$c356 = "when";
+  const peg$c357 = "then";
+  const peg$c358 = "date_add";
+  const peg$c359 = "dateadd";
+  const peg$c360 = "timestamp_add";
+  const peg$c361 = "timestampadd";
+  const peg$c362 = "date_sub";
+  const peg$c363 = "datesub";
+  const peg$c364 = "timestamp_sub";
+  const peg$c365 = "timestampsub";
+  const peg$c366 = "datediff";
+  const peg$c367 = "date_diff";
+  const peg$c368 = "substring";
+  const peg$c369 = "substr";
+  const peg$c370 = "mid";
+  const peg$c371 = "extract";
+  const peg$c372 = "trim";
+  const peg$c373 = "position";
+  const peg$c374 = "date";
+  const peg$c375 = "timestamp";
+  const peg$c376 = "cast";
+  const peg$c377 = "leading";
+  const peg$c378 = "trailing";
+  const peg$c379 = "both";
+  const peg$c380 = "filter";
+  const peg$c381 = "^";
+  const peg$c382 = "[]";
+  const peg$c383 = "strict";
+  const peg$c384 = "\u2018";
+  const peg$c385 = "\u2019";
+  const peg$c386 = "\\a";
+  const peg$c387 = "\\e";
+  const peg$c388 = "\\v";
+  const peg$c389 = "\\b";
+  const peg$c390 = "\\f";
+  const peg$c391 = "\\n";
+  const peg$c392 = "\\r";
+  const peg$c393 = "\\t";
+  const peg$c394 = "\\0";
+  const peg$c395 = "\\\"";
+  const peg$c396 = "\\x";
+  const peg$c397 = "\\";
+  const peg$c398 = "identifier";
+  const peg$c399 = "\u201C";
+  const peg$c400 = "\u201D";
+  const peg$c401 = "\"\"";
+  const peg$c402 = "``";
+  const peg$c403 = "join";
+  const peg$c404 = "left";
+  const peg$c405 = "right";
+  const peg$c406 = "cross";
+  const peg$c407 = "outer";
+  const peg$c408 = "array";
+  const peg$c409 = "totals";
+  const peg$c410 = "semi";
+  const peg$c411 = "anti";
+  const peg$c412 = "asof";
+  const peg$c413 = "global";
+  const peg$c414 = "--";
+  const peg$c415 = "#!";
+  const peg$c416 = "# ";
+  const peg$c417 = "//";
+  const peg$c418 = "/*";
+  const peg$c419 = "*/";
 
   const peg$r0 = /^[a-zA-Z0-9_]/;
   const peg$r1 = /^[0-9]/;
   const peg$r2 = /^[\n;]/;
   const peg$r3 = /^[),]/;
   const peg$r4 = /^[\n\r]/;
-  const peg$r5 = /^[^']/;
-  const peg$r6 = /^[a-zA-Z0-9_.%:]/;
-  const peg$r7 = /^[^}]/;
-  const peg$r8 = /^[a-zA-Z_]/;
-  const peg$r9 = /^[;]/;
-  const peg$r10 = /^[a-zA-Z0-9_\-]/;
-  const peg$r11 = /^[^`]/;
-  const peg$r12 = /^[*\/%+\-]/;
-  const peg$r13 = /^[*-\-\/]/;
-  const peg$r14 = /^[0-9_]/;
-  const peg$r15 = /^[eE]/;
-  const peg$r16 = /^[+\-]/;
-  const peg$r17 = /^[a-zA-Z0-9_$.]/;
-  const peg$r18 = /^[<->]/;
-  const peg$r19 = /^[*\/%]/;
-  const peg$r20 = /^[\-\u2212]/;
-  const peg$r21 = /^[:*0-9\-]/;
-  const peg$r22 = /^[^"]/;
-  const peg$r23 = /^["'-(A-Z_-z]/;
-  const peg$r24 = /^[^ ,)]/;
-  const peg$r25 = /^[a-zA-Z_\x80-\uFFFF]/;
-  const peg$r26 = /^[a-zA-Z0-9_\x80-\uFFFF]/;
-  const peg$r27 = /^[^()']/;
-  const peg$r28 = /^[^$]/;
-  const peg$r29 = /^[bB]/;
-  const peg$r30 = /^[01]/;
-  const peg$r31 = /^[xX]/;
-  const peg$r32 = /^[0-9a-fA-F]/;
-  const peg$r33 = /^[pP]/;
-  const peg$r34 = /^[a-zA-Z0-9_$]/;
-  const peg$r35 = /^[0-9:*]/;
-  const peg$r36 = /^[*]/;
-  const peg$r37 = /^[^'\\]/;
-  const peg$r38 = /^[a-zA-Z_$]/;
+  const peg$r5 = /^[a-zA-Z_]/;
+  const peg$r6 = /^[a-zA-Z_$]/;
+  const peg$r7 = /^[a-zA-Z0-9_$]/;
+  const peg$r8 = /^[^']/;
+  const peg$r9 = /^[a-zA-Z0-9_.%:]/;
+  const peg$r10 = /^[^}]/;
+  const peg$r11 = /^[;]/;
+  const peg$r12 = /^[a-zA-Z0-9_\-]/;
+  const peg$r13 = /^[^`]/;
+  const peg$r14 = /^[*\/%+\-]/;
+  const peg$r15 = /^[*-\-\/]/;
+  const peg$r16 = /^[0-9_]/;
+  const peg$r17 = /^[eE]/;
+  const peg$r18 = /^[+\-]/;
+  const peg$r19 = /^[a-zA-Z0-9_$.]/;
+  const peg$r20 = /^[<->]/;
+  const peg$r21 = /^[*\/%]/;
+  const peg$r22 = /^[\-\u2212]/;
+  const peg$r23 = /^[:*0-9\-]/;
+  const peg$r24 = /^[^"]/;
+  const peg$r25 = /^["'-(A-Z_-z]/;
+  const peg$r26 = /^[^ ,)]/;
+  const peg$r27 = /^[a-zA-Z_\x80-\uFFFF]/;
+  const peg$r28 = /^[a-zA-Z0-9_\x80-\uFFFF]/;
+  const peg$r29 = /^[^()']/;
+  const peg$r30 = /^[^$]/;
+  const peg$r31 = /^[bB]/;
+  const peg$r32 = /^[01]/;
+  const peg$r33 = /^[xX]/;
+  const peg$r34 = /^[0-9a-fA-F]/;
+  const peg$r35 = /^[pP]/;
+  const peg$r36 = /^[0-9:*]/;
+  const peg$r37 = /^[*]/;
+  const peg$r38 = /^[^'\\]/;
   const peg$r39 = /^[^"\\]/;
   const peg$r40 = /^[^`\\]/;
   const peg$r41 = /^[ \t\x85\xA0\xAD\u034F\u061C\u115F\u1160\u17B4\u17B5\u180E\u2000-\u200F\u2028\u2029\u202A-\u202F\u205F\u2060-\u2064\u206A-\u206F\u3000\u3164\uFEFF\uFFA0]/;
@@ -697,427 +724,454 @@ function peg$parse(input, options) {
   const peg$e14 = peg$literalExpectation("ALL", true);
   const peg$e15 = peg$literalExpectation("EXCEPT", true);
   const peg$e16 = peg$literalExpectation("NONE", true);
-  const peg$e17 = peg$literalExpectation(",", false);
-  const peg$e18 = peg$literalExpectation("USE", true);
-  const peg$e19 = peg$literalExpectation("SYSTEM", true);
-  const peg$e20 = peg$classExpectation(["\n", ";"], false, false, false);
-  const peg$e21 = peg$anyExpectation();
-  const peg$e22 = peg$literalExpectation("ALTER", true);
-  const peg$e23 = peg$literalExpectation("TEMPORARY", true);
-  const peg$e24 = peg$literalExpectation("TABLE", true);
-  const peg$e25 = peg$literalExpectation("(", false);
-  const peg$e26 = peg$literalExpectation(")", false);
-  const peg$e27 = peg$literalExpectation("ADD", true);
-  const peg$e28 = peg$literalExpectation("COLUMN", true);
-  const peg$e29 = peg$literalExpectation("IF", true);
-  const peg$e30 = peg$literalExpectation("NOT", true);
-  const peg$e31 = peg$literalExpectation("EXISTS", true);
-  const peg$e32 = peg$literalExpectation("AFTER", true);
-  const peg$e33 = peg$literalExpectation("FIRST", true);
-  const peg$e34 = peg$literalExpectation("DROP", true);
-  const peg$e35 = peg$literalExpectation("CLEAR", true);
-  const peg$e36 = peg$literalExpectation("MODIFY", true);
-  const peg$e37 = peg$literalExpectation("TYPE", true);
-  const peg$e38 = peg$literalExpectation("REMOVE", true);
-  const peg$e39 = peg$literalExpectation(".", false);
-  const peg$e40 = peg$literalExpectation("MATERIALIZED", true);
-  const peg$e41 = peg$literalExpectation("EPHEMERAL", true);
-  const peg$e42 = peg$literalExpectation("ALIAS", true);
-  const peg$e43 = peg$literalExpectation("COMMENT", true);
-  const peg$e44 = peg$literalExpectation("CODEC", true);
-  const peg$e45 = peg$literalExpectation("TTL", true);
-  const peg$e46 = peg$literalExpectation("STATISTICS", true);
-  const peg$e47 = peg$literalExpectation("SETTINGS", true);
-  const peg$e48 = peg$literalExpectation("NULL", true);
-  const peg$e49 = peg$literalExpectation("RESET", true);
-  const peg$e50 = peg$classExpectation([")", ","], false, false, false);
-  const peg$e51 = peg$literalExpectation("AUTO_INCREMENT", true);
-  const peg$e52 = peg$literalExpectation("COLLATE", true);
-  const peg$e53 = peg$literalExpectation("PRIMARY", true);
-  const peg$e54 = peg$literalExpectation("KEY", true);
-  const peg$e55 = peg$literalExpectation("SETTING", true);
-  const peg$e56 = peg$literalExpectation("RENAME", true);
-  const peg$e57 = peg$literalExpectation("MATERIALIZE", true);
-  const peg$e58 = peg$literalExpectation("WITH", true);
-  const peg$e59 = peg$literalExpectation("INDEX", true);
-  const peg$e60 = peg$literalExpectation("CHECK", true);
-  const peg$e61 = peg$literalExpectation("ASSUME", true);
-  const peg$e62 = peg$literalExpectation("GRANULARITY", true);
-  const peg$e63 = peg$literalExpectation("PROJECTION", true);
-  const peg$e64 = peg$literalExpectation("CONSTRAINT", true);
-  const peg$e65 = peg$literalExpectation("UPDATE", true);
-  const peg$e66 = peg$literalExpectation("WHERE", true);
-  const peg$e67 = peg$literalExpectation("=", false);
-  const peg$e68 = peg$literalExpectation("DELETE", true);
-  const peg$e69 = peg$literalExpectation("DETACH", true);
-  const peg$e70 = peg$literalExpectation("PART", true);
-  const peg$e71 = peg$literalExpectation("PARTITION", true);
-  const peg$e72 = peg$literalExpectation("DETACHED", true);
-  const peg$e73 = peg$literalExpectation("ATTACH", true);
-  const peg$e74 = peg$literalExpectation("FROM", true);
-  const peg$e75 = peg$literalExpectation("REPLACE", true);
-  const peg$e76 = peg$literalExpectation("MOVE", true);
-  const peg$e77 = peg$literalExpectation("DISK", true);
-  const peg$e78 = peg$literalExpectation("VOLUME", true);
-  const peg$e79 = peg$literalExpectation("SHARD", true);
-  const peg$e80 = peg$literalExpectation("FETCH", true);
-  const peg$e81 = peg$literalExpectation("ID", true);
-  const peg$e82 = peg$literalExpectation("FREEZE", true);
-  const peg$e83 = peg$literalExpectation("NAME", true);
-  const peg$e84 = peg$literalExpectation("ORDER", true);
-  const peg$e85 = peg$literalExpectation("BY", true);
-  const peg$e86 = peg$literalExpectation("SAMPLE", true);
-  const peg$e87 = peg$literalExpectation("QUERY", true);
-  const peg$e88 = peg$literalExpectation("APPLY", true);
-  const peg$e89 = peg$literalExpectation("DELETED", true);
-  const peg$e90 = peg$literalExpectation("MASK", true);
-  const peg$e91 = peg$literalExpectation("PATCHES", true);
-  const peg$e92 = peg$literalExpectation("REWRITE", true);
-  const peg$e93 = peg$literalExpectation("PARTS", true);
-  const peg$e94 = peg$literalExpectation("IN", true);
-  const peg$e95 = peg$literalExpectation("EXCHANGE", true);
-  const peg$e96 = peg$literalExpectation("SHOW", true);
-  const peg$e97 = peg$literalExpectation("GRANT", true);
-  const peg$e98 = peg$literalExpectation("REVOKE", true);
-  const peg$e99 = peg$literalExpectation("KILL", true);
-  const peg$e100 = peg$literalExpectation("UNDO", true);
-  const peg$e101 = peg$literalExpectation("BACKUP", true);
-  const peg$e102 = peg$literalExpectation("RESTORE", true);
-  const peg$e103 = peg$literalExpectation("BEGIN", true);
-  const peg$e104 = peg$literalExpectation("COMMIT", true);
-  const peg$e105 = peg$literalExpectation("ROLLBACK", true);
-  const peg$e106 = peg$literalExpectation("WATCH", true);
-  const peg$e107 = peg$literalExpectation("UNDROP", true);
-  const peg$e108 = peg$literalExpectation("ON", true);
-  const peg$e109 = peg$literalExpectation("EMPTY", true);
-  const peg$e110 = peg$literalExpectation("SYNC", true);
-  const peg$e111 = peg$literalExpectation("NO", true);
-  const peg$e112 = peg$literalExpectation("DELAY", true);
-  const peg$e113 = peg$literalExpectation("'", false);
-  const peg$e114 = peg$literalExpectation("''", false);
-  const peg$e115 = peg$literalExpectation("\\'", false);
-  const peg$e116 = peg$literalExpectation("\\\\", false);
-  const peg$e117 = peg$classExpectation(["\n", "\r"], false, false, false);
-  const peg$e118 = peg$literalExpectation("VIEW", true);
-  const peg$e119 = peg$literalExpectation("DICTIONARY", true);
-  const peg$e120 = peg$literalExpectation("DATABASE", true);
-  const peg$e121 = peg$literalExpectation("FUNCTION", true);
-  const peg$e122 = peg$literalExpectation("INSERT", true);
-  const peg$e123 = peg$literalExpectation("INFILE", true);
-  const peg$e124 = peg$literalExpectation("COMPRESSION", true);
-  const peg$e125 = peg$literalExpectation("VALUES", true);
-  const peg$e126 = peg$literalExpectation("FORMAT", true);
-  const peg$e127 = peg$literalExpectation("PARALLEL", true);
-  const peg$e128 = peg$literalExpectation("TABLES", true);
-  const peg$e129 = peg$literalExpectation("LIKE", true);
-  const peg$e130 = peg$literalExpectation("OPTIMIZE", true);
-  const peg$e131 = peg$literalExpectation("FINAL", true);
-  const peg$e132 = peg$literalExpectation("FORCE", true);
-  const peg$e133 = peg$literalExpectation("CLEANUP", true);
-  const peg$e134 = peg$literalExpectation("DEDUPLICATE", true);
-  const peg$e135 = peg$literalExpectation("DESCRIBE", true);
-  const peg$e136 = peg$literalExpectation("DESC", true);
-  const peg$e137 = peg$literalExpectation("SELECT", true);
-  const peg$e138 = peg$literalExpectation("CREATE", true);
-  const peg$e139 = peg$literalExpectation("USER", true);
-  const peg$e140 = peg$literalExpectation("QUOTA", true);
-  const peg$e141 = peg$literalExpectation("ROW", true);
-  const peg$e142 = peg$literalExpectation("POLICY", true);
-  const peg$e143 = peg$literalExpectation("PROFILE", true);
-  const peg$e144 = peg$literalExpectation("NAMED", true);
-  const peg$e145 = peg$literalExpectation("COLLECTION", true);
-  const peg$e146 = peg$literalExpectation("WORKLOAD", true);
-  const peg$e147 = peg$literalExpectation("RESOURCE", true);
-  const peg$e148 = peg$literalExpectation("PERMANENTLY", true);
-  const peg$e149 = peg$literalExpectation("UUID", true);
-  const peg$e150 = peg$literalExpectation("DICTIONARIES", true);
-  const peg$e151 = peg$literalExpectation("AND", true);
-  const peg$e152 = peg$literalExpectation("MUTATION", true);
-  const peg$e153 = peg$literalExpectation("ASYNC", true);
-  const peg$e154 = peg$literalExpectation("TEST", true);
-  const peg$e155 = peg$literalExpectation("OR", true);
-  const peg$e156 = peg$literalExpectation("INNER", true);
-  const peg$e157 = peg$literalExpectation("POPULATE", true);
-  const peg$e158 = peg$literalExpectation("UNIQUE", true);
-  const peg$e159 = peg$literalExpectation("EXPRESSION", true);
-  const peg$e160 = peg$literalExpectation("INJECTIVE", true);
-  const peg$e161 = peg$literalExpectation("IS_OBJECT_ID", true);
-  const peg$e162 = peg$literalExpectation("HIERARCHICAL", true);
-  const peg$e163 = peg$literalExpectation("BIDIRECTIONAL", true);
-  const peg$e164 = peg$literalExpectation("SOURCE", true);
-  const peg$e165 = peg$literalExpectation("LIFETIME", true);
-  const peg$e166 = peg$literalExpectation("LAYOUT", true);
-  const peg$e167 = peg$literalExpectation("RANGE", true);
-  const peg$e168 = peg$literalExpectation("MIN", true);
-  const peg$e169 = peg$literalExpectation("MAX", true);
-  const peg$e170 = peg$literalExpectation("ASC", true);
-  const peg$e171 = peg$literalExpectation("IDENTIFIED", true);
-  const peg$e172 = peg$literalExpectation("HOST", true);
-  const peg$e173 = peg$literalExpectation("GRANTEES", true);
-  const peg$e174 = peg$literalExpectation("VALID", true);
-  const peg$e175 = peg$literalExpectation("UNTIL", true);
-  const peg$e176 = peg$literalExpectation("CLUSTER", true);
-  const peg$e177 = peg$literalExpectation("@", false);
-  const peg$e178 = peg$classExpectation(["'"], true, false, false);
-  const peg$e179 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", ".", "%", ":"], false, false, false);
-  const peg$e180 = peg$literalExpectation("{", false);
-  const peg$e181 = peg$classExpectation(["}"], true, false, false);
-  const peg$e182 = peg$literalExpectation("}", false);
-  const peg$e183 = peg$literalExpectation("ssh_key", true);
-  const peg$e184 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
-  const peg$e185 = peg$literalExpectation("REALM", true);
-  const peg$e186 = peg$literalExpectation("SERVER", true);
-  const peg$e187 = peg$literalExpectation("ANY", true);
-  const peg$e188 = peg$literalExpectation("LOCAL", true);
-  const peg$e189 = peg$literalExpectation("REGEXP", true);
-  const peg$e190 = peg$literalExpectation("IP", true);
-  const peg$e191 = peg$literalExpectation("INHERIT", true);
-  const peg$e192 = peg$literalExpectation("CONST", true);
-  const peg$e193 = peg$literalExpectation("WRITABLE", true);
-  const peg$e194 = peg$literalExpectation("READONLY", true);
-  const peg$e195 = peg$literalExpectation("*", false);
-  const peg$e196 = peg$literalExpectation("FOR", true);
-  const peg$e197 = peg$literalExpectation("USING", true);
-  const peg$e198 = peg$literalExpectation("RESTRICTIVE", true);
-  const peg$e199 = peg$literalExpectation("PERMISSIVE", true);
-  const peg$e200 = peg$literalExpectation("KEYED", true);
-  const peg$e201 = peg$literalExpectation("RANDOMIZED", true);
-  const peg$e202 = peg$literalExpectation("INTERVAL", true);
-  const peg$e203 = peg$literalExpectation("SECOND", true);
-  const peg$e204 = peg$literalExpectation("MINUTE", true);
-  const peg$e205 = peg$literalExpectation("HOUR", true);
-  const peg$e206 = peg$literalExpectation("DAY", true);
-  const peg$e207 = peg$literalExpectation("WEEK", true);
-  const peg$e208 = peg$literalExpectation("MONTH", true);
-  const peg$e209 = peg$literalExpectation("QUARTER", true);
-  const peg$e210 = peg$literalExpectation("YEAR", true);
-  const peg$e211 = peg$literalExpectation("S", true);
-  const peg$e212 = peg$literalExpectation("TRACKING", true);
-  const peg$e213 = peg$literalExpectation("ONLY", true);
-  const peg$e214 = peg$literalExpectation("LIMITS", true);
-  const peg$e215 = peg$literalExpectation("RESULT", true);
-  const peg$e216 = peg$literalExpectation("READ", true);
-  const peg$e217 = peg$literalExpectation("EXECUTION", true);
-  const peg$e218 = peg$literalExpectation(" ", false);
-  const peg$e219 = peg$literalExpectation("ROWS", true);
-  const peg$e220 = peg$literalExpectation("BYTES", true);
-  const peg$e221 = peg$literalExpectation("TIME", true);
-  const peg$e222 = peg$literalExpectation("_", false);
-  const peg$e223 = peg$literalExpectation("WRITE", true);
-  const peg$e224 = peg$literalExpectation("WINDOW", true);
-  const peg$e225 = peg$classExpectation([";"], false, false, false);
-  const peg$e226 = peg$literalExpectation("LIVE", true);
-  const peg$e227 = peg$literalExpectation("REFRESH", true);
-  const peg$e228 = peg$literalExpectation("ENGINE", true);
-  const peg$e229 = peg$literalExpectation("CLONE", true);
-  const peg$e230 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
-  const peg$e231 = peg$literalExpectation("`", false);
-  const peg$e232 = peg$classExpectation(["`"], true, false, false);
-  const peg$e233 = peg$literalExpectation("FOREIGN", true);
-  const peg$e234 = peg$literalExpectation("REFERENCES", true);
-  const peg$e235 = peg$literalExpectation("CASCADE", true);
-  const peg$e236 = peg$literalExpectation("RESTRICT", true);
-  const peg$e237 = peg$literalExpectation("ACTION", true);
-  const peg$e238 = peg$classExpectation(["*", "/", "%", "+", "-"], false, false, false);
-  const peg$e239 = peg$literalExpectation("RECOMPRESS", true);
-  const peg$e240 = peg$literalExpectation("GROUP", true);
-  const peg$e241 = peg$literalExpectation("EXPLAIN", true);
-  const peg$e242 = peg$literalExpectation("TREE", true);
-  const peg$e243 = peg$literalExpectation("OVERRIDE", true);
-  const peg$e244 = peg$literalExpectation("CURRENT", true);
-  const peg$e245 = peg$literalExpectation("AST", true);
-  const peg$e246 = peg$literalExpectation("SYNTAX", true);
-  const peg$e247 = peg$literalExpectation("PLAN", true);
-  const peg$e248 = peg$literalExpectation("PIPELINE", true);
-  const peg$e249 = peg$literalExpectation("ESTIMATE", true);
-  const peg$e250 = peg$literalExpectation("INTERSECT", true);
-  const peg$e251 = peg$literalExpectation("DISTINCT", true);
-  const peg$e252 = peg$literalExpectation("TOP", true);
-  const peg$e253 = peg$literalExpectation("TIES", true);
-  const peg$e254 = peg$literalExpectation("RECURSIVE", true);
-  const peg$e255 = peg$literalExpectation("->", false);
-  const peg$e256 = peg$classExpectation([["*", "-"], "/"], false, false, false);
-  const peg$e257 = peg$literalExpectation("PREWHERE", true);
-  const peg$e258 = peg$literalExpectation("HAVING", true);
-  const peg$e259 = peg$literalExpectation("LIMIT", true);
-  const peg$e260 = peg$literalExpectation("OFFSET", true);
-  const peg$e261 = peg$literalExpectation("UNION", true);
-  const peg$e262 = peg$literalExpectation("/", false);
-  const peg$e263 = peg$classExpectation([["0", "9"], "_"], false, false, false);
-  const peg$e264 = peg$classExpectation(["e", "E"], false, false, false);
-  const peg$e265 = peg$classExpectation(["+", "-"], false, false, false);
-  const peg$e266 = peg$literalExpectation("PASTE", true);
-  const peg$e267 = peg$literalExpectation("GROUPING", true);
-  const peg$e268 = peg$literalExpectation("SETS", true);
-  const peg$e269 = peg$literalExpectation("ROLLUP", true);
-  const peg$e270 = peg$literalExpectation("CUBE", true);
-  const peg$e271 = peg$literalExpectation("QUALIFY", true);
-  const peg$e272 = peg$literalExpectation("NEXT", true);
-  const peg$e273 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "$", "."], false, false, false);
-  const peg$e274 = peg$literalExpectation("\"", false);
-  const peg$e275 = peg$literalExpectation("NULLS", true);
-  const peg$e276 = peg$literalExpectation("LAST", true);
-  const peg$e277 = peg$literalExpectation("FILL", true);
-  const peg$e278 = peg$literalExpectation("STEP", true);
-  const peg$e279 = peg$literalExpectation("STALENESS", true);
-  const peg$e280 = peg$literalExpectation("INTERPOLATE", true);
-  const peg$e281 = peg$literalExpectation("?", false);
-  const peg$e282 = peg$literalExpectation(":", false);
-  const peg$e283 = peg$literalExpectation("::", false);
-  const peg$e284 = peg$literalExpectation("IS", true);
-  const peg$e285 = peg$literalExpectation("<=>", false);
-  const peg$e286 = peg$literalExpectation(">=", false);
-  const peg$e287 = peg$literalExpectation("<=", false);
-  const peg$e288 = peg$literalExpectation("<>", false);
-  const peg$e289 = peg$literalExpectation("!=", false);
-  const peg$e290 = peg$literalExpectation("==", false);
-  const peg$e291 = peg$classExpectation([["<", ">"]], false, false, false);
-  const peg$e292 = peg$literalExpectation("+", false);
-  const peg$e293 = peg$literalExpectation("-", false);
-  const peg$e294 = peg$literalExpectation(">", false);
-  const peg$e295 = peg$literalExpectation("\u2212", false);
-  const peg$e296 = peg$literalExpectation("||", false);
-  const peg$e297 = peg$classExpectation(["*", "/", "%"], false, false, false);
-  const peg$e298 = peg$literalExpectation("DIV", true);
-  const peg$e299 = peg$literalExpectation("MOD", true);
-  const peg$e300 = peg$classExpectation(["-", "\u2212"], false, false, false);
-  const peg$e301 = peg$literalExpectation("RESPECT", true);
-  const peg$e302 = peg$literalExpectation("IGNORE", true);
-  const peg$e303 = peg$literalExpectation("OVER", true);
-  const peg$e304 = peg$literalExpectation("BETWEEN", true);
-  const peg$e305 = peg$literalExpectation("GROUPS", true);
-  const peg$e306 = peg$literalExpectation("UNBOUNDED", true);
-  const peg$e307 = peg$literalExpectation("PRECEDING", true);
-  const peg$e308 = peg$literalExpectation("FOLLOWING", true);
-  const peg$e309 = peg$literalExpectation("[", false);
-  const peg$e310 = peg$literalExpectation("]", false);
-  const peg$e311 = peg$classExpectation([":", "*", ["0", "9"], "-"], false, false, false);
-  const peg$e312 = peg$literalExpectation("DOUBLE", true);
-  const peg$e313 = peg$literalExpectation("PRECISION", true);
-  const peg$e314 = peg$literalExpectation("NATIONAL", true);
-  const peg$e315 = peg$literalExpectation("CHARACTER", true);
-  const peg$e316 = peg$literalExpectation("CHAR", true);
-  const peg$e317 = peg$literalExpectation("LARGE", true);
-  const peg$e318 = peg$literalExpectation("OBJECT", true);
-  const peg$e319 = peg$literalExpectation("VARYING", true);
-  const peg$e320 = peg$literalExpectation("NCHAR", true);
-  const peg$e321 = peg$literalExpectation("BINARY", true);
-  const peg$e322 = peg$literalExpectation("INT1", true);
-  const peg$e323 = peg$literalExpectation("SIGNED", true);
-  const peg$e324 = peg$literalExpectation("UNSIGNED", true);
-  const peg$e325 = peg$literalExpectation("TINYINT", true);
-  const peg$e326 = peg$literalExpectation("SMALLINT", true);
-  const peg$e327 = peg$literalExpectation("BIGINT", true);
-  const peg$e328 = peg$literalExpectation("MEDIUMINT", true);
-  const peg$e329 = peg$literalExpectation("INTEGER", true);
-  const peg$e330 = peg$literalExpectation("INT", true);
-  const peg$e331 = peg$classExpectation(["\""], true, false, false);
-  const peg$e332 = peg$literalExpectation("Enum8", true);
-  const peg$e333 = peg$literalExpectation("Enum16", true);
-  const peg$e334 = peg$literalExpectation("Enum", true);
-  const peg$e335 = peg$literalExpectation("SKIP", true);
-  const peg$e336 = peg$classExpectation(["\"", ["'", "("], ["A", "Z"], ["_", "z"]], false, false, false);
-  const peg$e337 = peg$classExpectation([" ", ",", ")"], true, false, false);
-  const peg$e338 = peg$classExpectation([["a", "z"], ["A", "Z"], "_", ["\x80", "\uFFFF"]], false, false, false);
-  const peg$e339 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", ["\x80", "\uFFFF"]], false, false, false);
-  const peg$e340 = peg$classExpectation(["(", ")", "'"], true, false, false);
-  const peg$e341 = peg$literalExpectation("@@", false);
-  const peg$e342 = peg$literalExpectation("session.", false);
-  const peg$e343 = peg$literalExpectation("global.", false);
-  const peg$e344 = peg$literalExpectation("local.", false);
-  const peg$e345 = peg$literalExpectation("$", false);
-  const peg$e346 = peg$classExpectation(["$"], true, false, false);
-  const peg$e347 = peg$literalExpectation("true", true);
-  const peg$e348 = peg$literalExpectation("false", true);
-  const peg$e349 = peg$classExpectation(["b", "B"], false, false, false);
-  const peg$e350 = peg$classExpectation(["0", "1"], false, false, false);
-  const peg$e351 = peg$classExpectation(["x", "X"], false, false, false);
-  const peg$e352 = peg$classExpectation([["0", "9"], ["a", "f"], ["A", "F"]], false, false, false);
-  const peg$e353 = peg$literalExpectation("0x", true);
-  const peg$e354 = peg$classExpectation(["p", "P"], false, false, false);
-  const peg$e355 = peg$literalExpectation("0b", true);
-  const peg$e356 = peg$literalExpectation("inf", true);
-  const peg$e357 = peg$literalExpectation("nan", true);
-  const peg$e358 = peg$literalExpectation("CASE", true);
-  const peg$e359 = peg$literalExpectation("ELSE", true);
-  const peg$e360 = peg$literalExpectation("END", true);
-  const peg$e361 = peg$literalExpectation("WHEN", true);
-  const peg$e362 = peg$literalExpectation("THEN", true);
-  const peg$e363 = peg$literalExpectation("DATE_ADD", true);
-  const peg$e364 = peg$literalExpectation("DATEADD", true);
-  const peg$e365 = peg$literalExpectation("TIMESTAMP_ADD", true);
-  const peg$e366 = peg$literalExpectation("TIMESTAMPADD", true);
-  const peg$e367 = peg$literalExpectation("DATE_SUB", true);
-  const peg$e368 = peg$literalExpectation("DATESUB", true);
-  const peg$e369 = peg$literalExpectation("TIMESTAMP_SUB", true);
-  const peg$e370 = peg$literalExpectation("TIMESTAMPSUB", true);
-  const peg$e371 = peg$literalExpectation("dateDiff", true);
-  const peg$e372 = peg$literalExpectation("DATEDIFF", true);
-  const peg$e373 = peg$literalExpectation("DATE_DIFF", true);
-  const peg$e374 = peg$literalExpectation("SUBSTRING", true);
-  const peg$e375 = peg$literalExpectation("SUBSTR", true);
-  const peg$e376 = peg$literalExpectation("MID", true);
-  const peg$e377 = peg$literalExpectation("EXTRACT", true);
-  const peg$e378 = peg$literalExpectation("TRIM", true);
-  const peg$e379 = peg$literalExpectation("POSITION", true);
-  const peg$e380 = peg$literalExpectation("DATE", true);
-  const peg$e381 = peg$literalExpectation("TIMESTAMP", true);
-  const peg$e382 = peg$literalExpectation("CAST", true);
-  const peg$e383 = peg$literalExpectation("LEADING", true);
-  const peg$e384 = peg$literalExpectation("TRAILING", true);
-  const peg$e385 = peg$literalExpectation("BOTH", true);
-  const peg$e386 = peg$literalExpectation("FILTER", true);
-  const peg$e387 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "$"], false, false, false);
-  const peg$e388 = peg$classExpectation([["0", "9"], ":", "*"], false, false, false);
-  const peg$e389 = peg$literalExpectation("^", false);
-  const peg$e390 = peg$literalExpectation("[]", false);
-  const peg$e391 = peg$classExpectation(["*"], false, false, false);
-  const peg$e392 = peg$literalExpectation("STRICT", true);
-  const peg$e393 = peg$literalExpectation("COLUMNS", true);
-  const peg$e394 = peg$literalExpectation("\u2018", false);
-  const peg$e395 = peg$literalExpectation("\u2019", false);
-  const peg$e396 = peg$literalExpectation("\\a", false);
-  const peg$e397 = peg$literalExpectation("\\e", false);
-  const peg$e398 = peg$literalExpectation("\\v", false);
-  const peg$e399 = peg$literalExpectation("\\b", false);
-  const peg$e400 = peg$literalExpectation("\\f", false);
-  const peg$e401 = peg$literalExpectation("\\n", false);
-  const peg$e402 = peg$literalExpectation("\\r", false);
-  const peg$e403 = peg$literalExpectation("\\t", false);
-  const peg$e404 = peg$literalExpectation("\\0", false);
-  const peg$e405 = peg$literalExpectation("\\\"", false);
-  const peg$e406 = peg$literalExpectation("\\x", false);
-  const peg$e407 = peg$literalExpectation("\\", false);
-  const peg$e408 = peg$classExpectation(["'", "\\"], true, false, false);
-  const peg$e409 = peg$literalExpectation("Identifier", true);
-  const peg$e410 = peg$literalExpectation("\u201C", false);
-  const peg$e411 = peg$literalExpectation("\u201D", false);
-  const peg$e412 = peg$classExpectation([["a", "z"], ["A", "Z"], "_", "$"], false, false, false);
-  const peg$e413 = peg$literalExpectation("\"\"", false);
-  const peg$e414 = peg$classExpectation(["\"", "\\"], true, false, false);
-  const peg$e415 = peg$literalExpectation("``", false);
-  const peg$e416 = peg$classExpectation(["`", "\\"], true, false, false);
-  const peg$e417 = peg$literalExpectation("JOIN", true);
-  const peg$e418 = peg$literalExpectation("LEFT", true);
-  const peg$e419 = peg$literalExpectation("RIGHT", true);
-  const peg$e420 = peg$literalExpectation("FULL", true);
-  const peg$e421 = peg$literalExpectation("CROSS", true);
-  const peg$e422 = peg$literalExpectation("OUTER", true);
-  const peg$e423 = peg$literalExpectation("ARRAY", true);
-  const peg$e424 = peg$literalExpectation("TOTALS", true);
-  const peg$e425 = peg$literalExpectation("SEMI", true);
-  const peg$e426 = peg$literalExpectation("ANTI", true);
-  const peg$e427 = peg$literalExpectation("ASOF", true);
-  const peg$e428 = peg$literalExpectation("GLOBAL", true);
-  const peg$e429 = peg$literalExpectation("ILIKE", true);
-  const peg$e430 = peg$classExpectation([" ", "\t", "\x85", "\xA0", "\xAD", "\u034F", "\u061C", "\u115F", "\u1160", "\u17B4", "\u17B5", "\u180E", ["\u2000", "\u200F"], "\u2028", "\u2029", ["\u202A", "\u202F"], "\u205F", ["\u2060", "\u2064"], ["\u206A", "\u206F"], "\u3000", "\u3164", "\uFEFF", "\uFFA0"], false, false, false);
-  const peg$e431 = peg$literalExpectation("--", false);
-  const peg$e432 = peg$literalExpectation("#!", false);
-  const peg$e433 = peg$literalExpectation("# ", false);
-  const peg$e434 = peg$literalExpectation("//", false);
-  const peg$e435 = peg$classExpectation(["\n"], false, false, false);
-  const peg$e436 = peg$literalExpectation("/*", false);
-  const peg$e437 = peg$literalExpectation("*/", false);
+  const peg$e17 = peg$literalExpectation("BEGIN", true);
+  const peg$e18 = peg$literalExpectation("START", true);
+  const peg$e19 = peg$literalExpectation("COMMIT", true);
+  const peg$e20 = peg$literalExpectation("ROLLBACK", true);
+  const peg$e21 = peg$literalExpectation("USE", true);
+  const peg$e22 = peg$literalExpectation("SYSTEM", true);
+  const peg$e23 = peg$classExpectation(["\n", ";"], false, false, false);
+  const peg$e24 = peg$anyExpectation();
+  const peg$e25 = peg$literalExpectation("ALTER", true);
+  const peg$e26 = peg$literalExpectation("TEMPORARY", true);
+  const peg$e27 = peg$literalExpectation("TABLE", true);
+  const peg$e28 = peg$literalExpectation(",", false);
+  const peg$e29 = peg$literalExpectation("(", false);
+  const peg$e30 = peg$literalExpectation(")", false);
+  const peg$e31 = peg$literalExpectation("ADD", true);
+  const peg$e32 = peg$literalExpectation("COLUMN", true);
+  const peg$e33 = peg$literalExpectation("IF", true);
+  const peg$e34 = peg$literalExpectation("NOT", true);
+  const peg$e35 = peg$literalExpectation("EXISTS", true);
+  const peg$e36 = peg$literalExpectation("AFTER", true);
+  const peg$e37 = peg$literalExpectation("FIRST", true);
+  const peg$e38 = peg$literalExpectation("DROP", true);
+  const peg$e39 = peg$literalExpectation("CLEAR", true);
+  const peg$e40 = peg$literalExpectation("MODIFY", true);
+  const peg$e41 = peg$literalExpectation("TYPE", true);
+  const peg$e42 = peg$literalExpectation("REMOVE", true);
+  const peg$e43 = peg$literalExpectation(".", false);
+  const peg$e44 = peg$literalExpectation("MATERIALIZED", true);
+  const peg$e45 = peg$literalExpectation("EPHEMERAL", true);
+  const peg$e46 = peg$literalExpectation("ALIAS", true);
+  const peg$e47 = peg$literalExpectation("COMMENT", true);
+  const peg$e48 = peg$literalExpectation("CODEC", true);
+  const peg$e49 = peg$literalExpectation("TTL", true);
+  const peg$e50 = peg$literalExpectation("STATISTICS", true);
+  const peg$e51 = peg$literalExpectation("SETTINGS", true);
+  const peg$e52 = peg$literalExpectation("NULL", true);
+  const peg$e53 = peg$literalExpectation("RESET", true);
+  const peg$e54 = peg$classExpectation([")", ","], false, false, false);
+  const peg$e55 = peg$literalExpectation("AUTO_INCREMENT", true);
+  const peg$e56 = peg$literalExpectation("COLLATE", true);
+  const peg$e57 = peg$literalExpectation("PRIMARY", true);
+  const peg$e58 = peg$literalExpectation("KEY", true);
+  const peg$e59 = peg$literalExpectation("SETTING", true);
+  const peg$e60 = peg$literalExpectation("RENAME", true);
+  const peg$e61 = peg$literalExpectation("MATERIALIZE", true);
+  const peg$e62 = peg$literalExpectation("WITH", true);
+  const peg$e63 = peg$literalExpectation("INDEX", true);
+  const peg$e64 = peg$literalExpectation("CHECK", true);
+  const peg$e65 = peg$literalExpectation("ASSUME", true);
+  const peg$e66 = peg$literalExpectation("GRANULARITY", true);
+  const peg$e67 = peg$literalExpectation("PROJECTION", true);
+  const peg$e68 = peg$literalExpectation("CONSTRAINT", true);
+  const peg$e69 = peg$literalExpectation("UPDATE", true);
+  const peg$e70 = peg$literalExpectation("WHERE", true);
+  const peg$e71 = peg$literalExpectation("=", false);
+  const peg$e72 = peg$literalExpectation("DELETE", true);
+  const peg$e73 = peg$literalExpectation("DETACH", true);
+  const peg$e74 = peg$literalExpectation("PART", true);
+  const peg$e75 = peg$literalExpectation("PARTITION", true);
+  const peg$e76 = peg$literalExpectation("DETACHED", true);
+  const peg$e77 = peg$literalExpectation("ATTACH", true);
+  const peg$e78 = peg$literalExpectation("FROM", true);
+  const peg$e79 = peg$literalExpectation("REPLACE", true);
+  const peg$e80 = peg$literalExpectation("MOVE", true);
+  const peg$e81 = peg$literalExpectation("DISK", true);
+  const peg$e82 = peg$literalExpectation("VOLUME", true);
+  const peg$e83 = peg$literalExpectation("SHARD", true);
+  const peg$e84 = peg$literalExpectation("FETCH", true);
+  const peg$e85 = peg$literalExpectation("ID", true);
+  const peg$e86 = peg$literalExpectation("FREEZE", true);
+  const peg$e87 = peg$literalExpectation("NAME", true);
+  const peg$e88 = peg$literalExpectation("ORDER", true);
+  const peg$e89 = peg$literalExpectation("BY", true);
+  const peg$e90 = peg$literalExpectation("SAMPLE", true);
+  const peg$e91 = peg$literalExpectation("QUERY", true);
+  const peg$e92 = peg$literalExpectation("APPLY", true);
+  const peg$e93 = peg$literalExpectation("DELETED", true);
+  const peg$e94 = peg$literalExpectation("MASK", true);
+  const peg$e95 = peg$literalExpectation("PATCHES", true);
+  const peg$e96 = peg$literalExpectation("REWRITE", true);
+  const peg$e97 = peg$literalExpectation("PARTS", true);
+  const peg$e98 = peg$literalExpectation("IN", true);
+  const peg$e99 = peg$literalExpectation("ON", true);
+  const peg$e100 = peg$literalExpectation("EMPTY", true);
+  const peg$e101 = peg$literalExpectation("SYNC", true);
+  const peg$e102 = peg$literalExpectation("NO", true);
+  const peg$e103 = peg$literalExpectation("DELAY", true);
+  const peg$e104 = peg$literalExpectation("'", false);
+  const peg$e105 = peg$literalExpectation("''", false);
+  const peg$e106 = peg$literalExpectation("\\'", false);
+  const peg$e107 = peg$literalExpectation("\\\\", false);
+  const peg$e108 = peg$classExpectation(["\n", "\r"], false, false, false);
+  const peg$e109 = peg$literalExpectation("UNDROP", true);
+  const peg$e110 = peg$literalExpectation("UUID", true);
+  const peg$e111 = peg$literalExpectation("BACKUP", true);
+  const peg$e112 = peg$literalExpectation("RESTORE", true);
+  const peg$e113 = peg$literalExpectation("ASYNC", true);
+  const peg$e114 = peg$literalExpectation("DATABASES", true);
+  const peg$e115 = peg$literalExpectation("TABLES", true);
+  const peg$e116 = peg$literalExpectation("DICTIONARY", true);
+  const peg$e117 = peg$literalExpectation("VIEW", true);
+  const peg$e118 = peg$literalExpectation("DATABASE", true);
+  const peg$e119 = peg$literalExpectation("FUNCTION", true);
+  const peg$e120 = peg$literalExpectation("NAMED", true);
+  const peg$e121 = peg$literalExpectation("COLLECTION", true);
+  const peg$e122 = peg$literalExpectation("PARTITIONS", true);
+  const peg$e123 = peg$literalExpectation("COLUMNS", true);
+  const peg$e124 = peg$literalExpectation("GRANT", true);
+  const peg$e125 = peg$literalExpectation("REVOKE", true);
+  const peg$e126 = peg$literalExpectation("ADMIN", true);
+  const peg$e127 = peg$literalExpectation("OPTION", true);
+  const peg$e128 = peg$literalExpectation("FOR", true);
+  const peg$e129 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
+  const peg$e130 = peg$literalExpectation("*", false);
+  const peg$e131 = peg$classExpectation([["a", "z"], ["A", "Z"], "_", "$"], false, false, false);
+  const peg$e132 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "$"], false, false, false);
+  const peg$e133 = peg$literalExpectation("`", false);
+  const peg$e134 = peg$literalExpectation("CURRENT_USER", true);
+  const peg$e135 = peg$literalExpectation("USER", true);
+  const peg$e136 = peg$literalExpectation("IDENTIFIED", true);
+  const peg$e137 = peg$literalExpectation("HOST", true);
+  const peg$e138 = peg$literalExpectation("GRANTEES", true);
+  const peg$e139 = peg$literalExpectation("VALID", true);
+  const peg$e140 = peg$literalExpectation("UNTIL", true);
+  const peg$e141 = peg$literalExpectation("QUOTA", true);
+  const peg$e142 = peg$literalExpectation("ROW", true);
+  const peg$e143 = peg$literalExpectation("POLICY", true);
+  const peg$e144 = peg$literalExpectation("SELECT", true);
+  const peg$e145 = peg$literalExpectation("USING", true);
+  const peg$e146 = peg$literalExpectation("RESTRICTIVE", true);
+  const peg$e147 = peg$literalExpectation("PERMISSIVE", true);
+  const peg$e148 = peg$literalExpectation("CLUSTER", true);
+  const peg$e149 = peg$literalExpectation("PROFILE", true);
+  const peg$e150 = peg$literalExpectation("SHOW", true);
+  const peg$e151 = peg$literalExpectation("CREATE", true);
+  const peg$e152 = peg$literalExpectation("POLICIES", true);
+  const peg$e153 = peg$literalExpectation("USERS", true);
+  const peg$e154 = peg$literalExpectation("ROLES", true);
+  const peg$e155 = peg$literalExpectation("QUOTAS", true);
+  const peg$e156 = peg$literalExpectation("PROFILES", true);
+  const peg$e157 = peg$literalExpectation("COLLECTIONS", true);
+  const peg$e158 = peg$literalExpectation("EXTENDED", true);
+  const peg$e159 = peg$literalExpectation("FULL", true);
+  const peg$e160 = peg$literalExpectation("FIELDS", true);
+  const peg$e161 = peg$literalExpectation("LIMIT", true);
+  const peg$e162 = peg$literalExpectation("INDEXES", true);
+  const peg$e163 = peg$literalExpectation("INDICES", true);
+  const peg$e164 = peg$literalExpectation("KEYS", true);
+  const peg$e165 = peg$literalExpectation("GRANTS", true);
+  const peg$e166 = peg$literalExpectation("IMPLICIT", true);
+  const peg$e167 = peg$literalExpectation("FINAL", true);
+  const peg$e168 = peg$literalExpectation("DICTIONARIES", true);
+  const peg$e169 = peg$literalExpectation("CHANGED", true);
+  const peg$e170 = peg$literalExpectation("CLUSTERS", true);
+  const peg$e171 = peg$literalExpectation("CURRENT", true);
+  const peg$e172 = peg$literalExpectation("ENABLED", true);
+  const peg$e173 = peg$literalExpectation("WARNINGS", true);
+  const peg$e174 = peg$literalExpectation("PRIVILEGES", true);
+  const peg$e175 = peg$literalExpectation("ENGINES", true);
+  const peg$e176 = peg$literalExpectation("MERGES", true);
+  const peg$e177 = peg$literalExpectation("ACCESS", true);
+  const peg$e178 = peg$literalExpectation("PROCESSLIST", true);
+  const peg$e179 = peg$literalExpectation("FUNCTIONS", true);
+  const peg$e180 = peg$literalExpectation("ILIKE", true);
+  const peg$e181 = peg$literalExpectation("LIKE", true);
+  const peg$e182 = peg$literalExpectation("INSERT", true);
+  const peg$e183 = peg$literalExpectation("INFILE", true);
+  const peg$e184 = peg$literalExpectation("COMPRESSION", true);
+  const peg$e185 = peg$literalExpectation("VALUES", true);
+  const peg$e186 = peg$literalExpectation("FORMAT", true);
+  const peg$e187 = peg$literalExpectation("PARALLEL", true);
+  const peg$e188 = peg$literalExpectation("OPTIMIZE", true);
+  const peg$e189 = peg$literalExpectation("FORCE", true);
+  const peg$e190 = peg$literalExpectation("CLEANUP", true);
+  const peg$e191 = peg$literalExpectation("DEDUPLICATE", true);
+  const peg$e192 = peg$literalExpectation("DESCRIBE", true);
+  const peg$e193 = peg$literalExpectation("DESC", true);
+  const peg$e194 = peg$literalExpectation("WORKLOAD", true);
+  const peg$e195 = peg$literalExpectation("RESOURCE", true);
+  const peg$e196 = peg$literalExpectation("PERMANENTLY", true);
+  const peg$e197 = peg$literalExpectation("EXCHANGE", true);
+  const peg$e198 = peg$literalExpectation("AND", true);
+  const peg$e199 = peg$literalExpectation("KILL", true);
+  const peg$e200 = peg$literalExpectation("MUTATION", true);
+  const peg$e201 = peg$literalExpectation("TEST", true);
+  const peg$e202 = peg$literalExpectation("OR", true);
+  const peg$e203 = peg$literalExpectation("INNER", true);
+  const peg$e204 = peg$literalExpectation("POPULATE", true);
+  const peg$e205 = peg$literalExpectation("UNIQUE", true);
+  const peg$e206 = peg$literalExpectation("EXPRESSION", true);
+  const peg$e207 = peg$literalExpectation("INJECTIVE", true);
+  const peg$e208 = peg$literalExpectation("IS_OBJECT_ID", true);
+  const peg$e209 = peg$literalExpectation("HIERARCHICAL", true);
+  const peg$e210 = peg$literalExpectation("BIDIRECTIONAL", true);
+  const peg$e211 = peg$literalExpectation("SOURCE", true);
+  const peg$e212 = peg$literalExpectation("LIFETIME", true);
+  const peg$e213 = peg$literalExpectation("LAYOUT", true);
+  const peg$e214 = peg$literalExpectation("RANGE", true);
+  const peg$e215 = peg$literalExpectation("MIN", true);
+  const peg$e216 = peg$literalExpectation("MAX", true);
+  const peg$e217 = peg$literalExpectation("ASC", true);
+  const peg$e218 = peg$literalExpectation("@", false);
+  const peg$e219 = peg$classExpectation(["'"], true, false, false);
+  const peg$e220 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", ".", "%", ":"], false, false, false);
+  const peg$e221 = peg$literalExpectation("{", false);
+  const peg$e222 = peg$classExpectation(["}"], true, false, false);
+  const peg$e223 = peg$literalExpectation("}", false);
+  const peg$e224 = peg$literalExpectation("ssh_key", true);
+  const peg$e225 = peg$literalExpectation("REALM", true);
+  const peg$e226 = peg$literalExpectation("SERVER", true);
+  const peg$e227 = peg$literalExpectation("ANY", true);
+  const peg$e228 = peg$literalExpectation("LOCAL", true);
+  const peg$e229 = peg$literalExpectation("REGEXP", true);
+  const peg$e230 = peg$literalExpectation("IP", true);
+  const peg$e231 = peg$literalExpectation("INHERIT", true);
+  const peg$e232 = peg$literalExpectation("CONST", true);
+  const peg$e233 = peg$literalExpectation("WRITABLE", true);
+  const peg$e234 = peg$literalExpectation("READONLY", true);
+  const peg$e235 = peg$literalExpectation("KEYED", true);
+  const peg$e236 = peg$literalExpectation("RANDOMIZED", true);
+  const peg$e237 = peg$literalExpectation("INTERVAL", true);
+  const peg$e238 = peg$literalExpectation("SECOND", true);
+  const peg$e239 = peg$literalExpectation("MINUTE", true);
+  const peg$e240 = peg$literalExpectation("HOUR", true);
+  const peg$e241 = peg$literalExpectation("DAY", true);
+  const peg$e242 = peg$literalExpectation("WEEK", true);
+  const peg$e243 = peg$literalExpectation("MONTH", true);
+  const peg$e244 = peg$literalExpectation("QUARTER", true);
+  const peg$e245 = peg$literalExpectation("YEAR", true);
+  const peg$e246 = peg$literalExpectation("S", true);
+  const peg$e247 = peg$literalExpectation("TRACKING", true);
+  const peg$e248 = peg$literalExpectation("ONLY", true);
+  const peg$e249 = peg$literalExpectation("LIMITS", true);
+  const peg$e250 = peg$literalExpectation("RESULT", true);
+  const peg$e251 = peg$literalExpectation("READ", true);
+  const peg$e252 = peg$literalExpectation("EXECUTION", true);
+  const peg$e253 = peg$literalExpectation(" ", false);
+  const peg$e254 = peg$literalExpectation("ROWS", true);
+  const peg$e255 = peg$literalExpectation("BYTES", true);
+  const peg$e256 = peg$literalExpectation("TIME", true);
+  const peg$e257 = peg$literalExpectation("_", false);
+  const peg$e258 = peg$literalExpectation("WRITE", true);
+  const peg$e259 = peg$literalExpectation("WINDOW", true);
+  const peg$e260 = peg$classExpectation([";"], false, false, false);
+  const peg$e261 = peg$literalExpectation("LIVE", true);
+  const peg$e262 = peg$literalExpectation("REFRESH", true);
+  const peg$e263 = peg$literalExpectation("ENGINE", true);
+  const peg$e264 = peg$literalExpectation("CLONE", true);
+  const peg$e265 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
+  const peg$e266 = peg$classExpectation(["`"], true, false, false);
+  const peg$e267 = peg$literalExpectation("FOREIGN", true);
+  const peg$e268 = peg$literalExpectation("REFERENCES", true);
+  const peg$e269 = peg$literalExpectation("CASCADE", true);
+  const peg$e270 = peg$literalExpectation("RESTRICT", true);
+  const peg$e271 = peg$literalExpectation("ACTION", true);
+  const peg$e272 = peg$classExpectation(["*", "/", "%", "+", "-"], false, false, false);
+  const peg$e273 = peg$literalExpectation("RECOMPRESS", true);
+  const peg$e274 = peg$literalExpectation("GROUP", true);
+  const peg$e275 = peg$literalExpectation("EXPLAIN", true);
+  const peg$e276 = peg$literalExpectation("TREE", true);
+  const peg$e277 = peg$literalExpectation("OVERRIDE", true);
+  const peg$e278 = peg$literalExpectation("AST", true);
+  const peg$e279 = peg$literalExpectation("SYNTAX", true);
+  const peg$e280 = peg$literalExpectation("PLAN", true);
+  const peg$e281 = peg$literalExpectation("PIPELINE", true);
+  const peg$e282 = peg$literalExpectation("ESTIMATE", true);
+  const peg$e283 = peg$literalExpectation("INTERSECT", true);
+  const peg$e284 = peg$literalExpectation("DISTINCT", true);
+  const peg$e285 = peg$literalExpectation("TOP", true);
+  const peg$e286 = peg$literalExpectation("TIES", true);
+  const peg$e287 = peg$literalExpectation("RECURSIVE", true);
+  const peg$e288 = peg$literalExpectation("->", false);
+  const peg$e289 = peg$classExpectation([["*", "-"], "/"], false, false, false);
+  const peg$e290 = peg$literalExpectation("PREWHERE", true);
+  const peg$e291 = peg$literalExpectation("HAVING", true);
+  const peg$e292 = peg$literalExpectation("OFFSET", true);
+  const peg$e293 = peg$literalExpectation("UNION", true);
+  const peg$e294 = peg$literalExpectation("/", false);
+  const peg$e295 = peg$classExpectation([["0", "9"], "_"], false, false, false);
+  const peg$e296 = peg$classExpectation(["e", "E"], false, false, false);
+  const peg$e297 = peg$classExpectation(["+", "-"], false, false, false);
+  const peg$e298 = peg$literalExpectation("PASTE", true);
+  const peg$e299 = peg$literalExpectation("GROUPING", true);
+  const peg$e300 = peg$literalExpectation("SETS", true);
+  const peg$e301 = peg$literalExpectation("ROLLUP", true);
+  const peg$e302 = peg$literalExpectation("CUBE", true);
+  const peg$e303 = peg$literalExpectation("QUALIFY", true);
+  const peg$e304 = peg$literalExpectation("NEXT", true);
+  const peg$e305 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "$", "."], false, false, false);
+  const peg$e306 = peg$literalExpectation("\"", false);
+  const peg$e307 = peg$literalExpectation("NULLS", true);
+  const peg$e308 = peg$literalExpectation("LAST", true);
+  const peg$e309 = peg$literalExpectation("FILL", true);
+  const peg$e310 = peg$literalExpectation("STEP", true);
+  const peg$e311 = peg$literalExpectation("STALENESS", true);
+  const peg$e312 = peg$literalExpectation("INTERPOLATE", true);
+  const peg$e313 = peg$literalExpectation("?", false);
+  const peg$e314 = peg$literalExpectation(":", false);
+  const peg$e315 = peg$literalExpectation("::", false);
+  const peg$e316 = peg$literalExpectation("IS", true);
+  const peg$e317 = peg$literalExpectation("<=>", false);
+  const peg$e318 = peg$literalExpectation(">=", false);
+  const peg$e319 = peg$literalExpectation("<=", false);
+  const peg$e320 = peg$literalExpectation("<>", false);
+  const peg$e321 = peg$literalExpectation("!=", false);
+  const peg$e322 = peg$literalExpectation("==", false);
+  const peg$e323 = peg$classExpectation([["<", ">"]], false, false, false);
+  const peg$e324 = peg$literalExpectation("+", false);
+  const peg$e325 = peg$literalExpectation("-", false);
+  const peg$e326 = peg$literalExpectation(">", false);
+  const peg$e327 = peg$literalExpectation("\u2212", false);
+  const peg$e328 = peg$literalExpectation("||", false);
+  const peg$e329 = peg$classExpectation(["*", "/", "%"], false, false, false);
+  const peg$e330 = peg$literalExpectation("DIV", true);
+  const peg$e331 = peg$literalExpectation("MOD", true);
+  const peg$e332 = peg$classExpectation(["-", "\u2212"], false, false, false);
+  const peg$e333 = peg$literalExpectation("RESPECT", true);
+  const peg$e334 = peg$literalExpectation("IGNORE", true);
+  const peg$e335 = peg$literalExpectation("OVER", true);
+  const peg$e336 = peg$literalExpectation("BETWEEN", true);
+  const peg$e337 = peg$literalExpectation("GROUPS", true);
+  const peg$e338 = peg$literalExpectation("UNBOUNDED", true);
+  const peg$e339 = peg$literalExpectation("PRECEDING", true);
+  const peg$e340 = peg$literalExpectation("FOLLOWING", true);
+  const peg$e341 = peg$literalExpectation("[", false);
+  const peg$e342 = peg$literalExpectation("]", false);
+  const peg$e343 = peg$classExpectation([":", "*", ["0", "9"], "-"], false, false, false);
+  const peg$e344 = peg$literalExpectation("DOUBLE", true);
+  const peg$e345 = peg$literalExpectation("PRECISION", true);
+  const peg$e346 = peg$literalExpectation("NATIONAL", true);
+  const peg$e347 = peg$literalExpectation("CHARACTER", true);
+  const peg$e348 = peg$literalExpectation("CHAR", true);
+  const peg$e349 = peg$literalExpectation("LARGE", true);
+  const peg$e350 = peg$literalExpectation("OBJECT", true);
+  const peg$e351 = peg$literalExpectation("VARYING", true);
+  const peg$e352 = peg$literalExpectation("NCHAR", true);
+  const peg$e353 = peg$literalExpectation("BINARY", true);
+  const peg$e354 = peg$literalExpectation("INT1", true);
+  const peg$e355 = peg$literalExpectation("SIGNED", true);
+  const peg$e356 = peg$literalExpectation("UNSIGNED", true);
+  const peg$e357 = peg$literalExpectation("TINYINT", true);
+  const peg$e358 = peg$literalExpectation("SMALLINT", true);
+  const peg$e359 = peg$literalExpectation("BIGINT", true);
+  const peg$e360 = peg$literalExpectation("MEDIUMINT", true);
+  const peg$e361 = peg$literalExpectation("INTEGER", true);
+  const peg$e362 = peg$literalExpectation("INT", true);
+  const peg$e363 = peg$classExpectation(["\""], true, false, false);
+  const peg$e364 = peg$literalExpectation("Enum8", true);
+  const peg$e365 = peg$literalExpectation("Enum16", true);
+  const peg$e366 = peg$literalExpectation("Enum", true);
+  const peg$e367 = peg$literalExpectation("SKIP", true);
+  const peg$e368 = peg$classExpectation(["\"", ["'", "("], ["A", "Z"], ["_", "z"]], false, false, false);
+  const peg$e369 = peg$classExpectation([" ", ",", ")"], true, false, false);
+  const peg$e370 = peg$classExpectation([["a", "z"], ["A", "Z"], "_", ["\x80", "\uFFFF"]], false, false, false);
+  const peg$e371 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", ["\x80", "\uFFFF"]], false, false, false);
+  const peg$e372 = peg$classExpectation(["(", ")", "'"], true, false, false);
+  const peg$e373 = peg$literalExpectation("@@", false);
+  const peg$e374 = peg$literalExpectation("session.", false);
+  const peg$e375 = peg$literalExpectation("global.", false);
+  const peg$e376 = peg$literalExpectation("local.", false);
+  const peg$e377 = peg$literalExpectation("$", false);
+  const peg$e378 = peg$classExpectation(["$"], true, false, false);
+  const peg$e379 = peg$literalExpectation("true", true);
+  const peg$e380 = peg$literalExpectation("false", true);
+  const peg$e381 = peg$classExpectation(["b", "B"], false, false, false);
+  const peg$e382 = peg$classExpectation(["0", "1"], false, false, false);
+  const peg$e383 = peg$classExpectation(["x", "X"], false, false, false);
+  const peg$e384 = peg$classExpectation([["0", "9"], ["a", "f"], ["A", "F"]], false, false, false);
+  const peg$e385 = peg$literalExpectation("0x", true);
+  const peg$e386 = peg$classExpectation(["p", "P"], false, false, false);
+  const peg$e387 = peg$literalExpectation("0b", true);
+  const peg$e388 = peg$literalExpectation("inf", true);
+  const peg$e389 = peg$literalExpectation("nan", true);
+  const peg$e390 = peg$literalExpectation("CASE", true);
+  const peg$e391 = peg$literalExpectation("ELSE", true);
+  const peg$e392 = peg$literalExpectation("END", true);
+  const peg$e393 = peg$literalExpectation("WHEN", true);
+  const peg$e394 = peg$literalExpectation("THEN", true);
+  const peg$e395 = peg$literalExpectation("DATE_ADD", true);
+  const peg$e396 = peg$literalExpectation("DATEADD", true);
+  const peg$e397 = peg$literalExpectation("TIMESTAMP_ADD", true);
+  const peg$e398 = peg$literalExpectation("TIMESTAMPADD", true);
+  const peg$e399 = peg$literalExpectation("DATE_SUB", true);
+  const peg$e400 = peg$literalExpectation("DATESUB", true);
+  const peg$e401 = peg$literalExpectation("TIMESTAMP_SUB", true);
+  const peg$e402 = peg$literalExpectation("TIMESTAMPSUB", true);
+  const peg$e403 = peg$literalExpectation("dateDiff", true);
+  const peg$e404 = peg$literalExpectation("DATEDIFF", true);
+  const peg$e405 = peg$literalExpectation("DATE_DIFF", true);
+  const peg$e406 = peg$literalExpectation("SUBSTRING", true);
+  const peg$e407 = peg$literalExpectation("SUBSTR", true);
+  const peg$e408 = peg$literalExpectation("MID", true);
+  const peg$e409 = peg$literalExpectation("EXTRACT", true);
+  const peg$e410 = peg$literalExpectation("TRIM", true);
+  const peg$e411 = peg$literalExpectation("POSITION", true);
+  const peg$e412 = peg$literalExpectation("DATE", true);
+  const peg$e413 = peg$literalExpectation("TIMESTAMP", true);
+  const peg$e414 = peg$literalExpectation("CAST", true);
+  const peg$e415 = peg$literalExpectation("LEADING", true);
+  const peg$e416 = peg$literalExpectation("TRAILING", true);
+  const peg$e417 = peg$literalExpectation("BOTH", true);
+  const peg$e418 = peg$literalExpectation("FILTER", true);
+  const peg$e419 = peg$classExpectation([["0", "9"], ":", "*"], false, false, false);
+  const peg$e420 = peg$literalExpectation("^", false);
+  const peg$e421 = peg$literalExpectation("[]", false);
+  const peg$e422 = peg$classExpectation(["*"], false, false, false);
+  const peg$e423 = peg$literalExpectation("STRICT", true);
+  const peg$e424 = peg$literalExpectation("\u2018", false);
+  const peg$e425 = peg$literalExpectation("\u2019", false);
+  const peg$e426 = peg$literalExpectation("\\a", false);
+  const peg$e427 = peg$literalExpectation("\\e", false);
+  const peg$e428 = peg$literalExpectation("\\v", false);
+  const peg$e429 = peg$literalExpectation("\\b", false);
+  const peg$e430 = peg$literalExpectation("\\f", false);
+  const peg$e431 = peg$literalExpectation("\\n", false);
+  const peg$e432 = peg$literalExpectation("\\r", false);
+  const peg$e433 = peg$literalExpectation("\\t", false);
+  const peg$e434 = peg$literalExpectation("\\0", false);
+  const peg$e435 = peg$literalExpectation("\\\"", false);
+  const peg$e436 = peg$literalExpectation("\\x", false);
+  const peg$e437 = peg$literalExpectation("\\", false);
+  const peg$e438 = peg$classExpectation(["'", "\\"], true, false, false);
+  const peg$e439 = peg$literalExpectation("Identifier", true);
+  const peg$e440 = peg$literalExpectation("\u201C", false);
+  const peg$e441 = peg$literalExpectation("\u201D", false);
+  const peg$e442 = peg$literalExpectation("\"\"", false);
+  const peg$e443 = peg$classExpectation(["\"", "\\"], true, false, false);
+  const peg$e444 = peg$literalExpectation("``", false);
+  const peg$e445 = peg$classExpectation(["`", "\\"], true, false, false);
+  const peg$e446 = peg$literalExpectation("JOIN", true);
+  const peg$e447 = peg$literalExpectation("LEFT", true);
+  const peg$e448 = peg$literalExpectation("RIGHT", true);
+  const peg$e449 = peg$literalExpectation("CROSS", true);
+  const peg$e450 = peg$literalExpectation("OUTER", true);
+  const peg$e451 = peg$literalExpectation("ARRAY", true);
+  const peg$e452 = peg$literalExpectation("TOTALS", true);
+  const peg$e453 = peg$literalExpectation("SEMI", true);
+  const peg$e454 = peg$literalExpectation("ANTI", true);
+  const peg$e455 = peg$literalExpectation("ASOF", true);
+  const peg$e456 = peg$literalExpectation("GLOBAL", true);
+  const peg$e457 = peg$classExpectation([" ", "\t", "\x85", "\xA0", "\xAD", "\u034F", "\u061C", "\u115F", "\u1160", "\u17B4", "\u17B5", "\u180E", ["\u2000", "\u200F"], "\u2028", "\u2029", ["\u202A", "\u202F"], "\u205F", ["\u2060", "\u2064"], ["\u206A", "\u206F"], "\u3000", "\u3164", "\uFEFF", "\uFFA0"], false, false, false);
+  const peg$e458 = peg$literalExpectation("--", false);
+  const peg$e459 = peg$literalExpectation("#!", false);
+  const peg$e460 = peg$literalExpectation("# ", false);
+  const peg$e461 = peg$literalExpectation("//", false);
+  const peg$e462 = peg$classExpectation(["\n"], false, false, false);
+  const peg$e463 = peg$literalExpectation("/*", false);
+  const peg$e464 = peg$literalExpectation("*/", false);
 
   function peg$f0(pre, head, headWs, rest, trailing, finalWs) {
     head = addLeading(head, flattenWs(pre));
@@ -1172,17 +1226,18 @@ function peg$parse(input, options) {
   function peg$f7(user, stmt) {
     return loc({ kind: 'executeAs', user, statement: stmt });
   }
-  function peg$f8(snapshot) {    return loc({ kind: 'transactionControl', snapshot });  }
+  function peg$f8(snapshot) {    return loc({ kind: 'transactionControl', action: 'snapshot', snapshot });  }
   function peg$f9(roles, users) {    return loc({ kind: 'setRole', roles, users });  }
   function peg$f10(items) {    return loc({ kind: 'set', settings: items });  }
   function peg$f11(except) {    return { kind: 'all', except: except ? except[4] : undefined };  }
   function peg$f12() {    return { kind: 'none' };  }
   function peg$f13(names) {    return { kind: 'names', names };  }
-  function peg$f14(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f15(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f16(db) {    return loc({ kind: 'use', database: db });  }
-  function peg$f17(body) {    return loc({ kind: 'system', body: ('SYSTEM ' + body.trim()).trim() });  }
-  function peg$f18(table, onCluster, head, tail, preSettings, format, postSettings) {
+  function peg$f14() {    return loc({ kind: 'transactionControl', action: 'begin' });  }
+  function peg$f15() {    return loc({ kind: 'transactionControl', action: 'commit' });  }
+  function peg$f16() {    return loc({ kind: 'transactionControl', action: 'rollback' });  }
+  function peg$f17(db) {    return loc({ kind: 'use', database: db });  }
+  function peg$f18(body) {    return loc({ kind: 'system', body: ('SYSTEM ' + body.trim()).trim() });  }
+  function peg$f19(table, onCluster, head, tail, preSettings, format, postSettings) {
     const commands = [head, ...tail.map(t => t[3])];
     const result = loc({ kind: 'alter', table, commands });
     if (onCluster !== null) result.onCluster = onCluster[1];
@@ -1191,33 +1246,33 @@ function peg$parse(input, options) {
     if (format !== null) result.format = format[1];
     return result;
   }
-  function peg$f19(cmd) {    return { ...cmd, parenthesized: true };  }
-  function peg$f20(ifNotExists, col, after) {
+  function peg$f20(cmd) {    return { ...cmd, parenthesized: true };  }
+  function peg$f21(ifNotExists, col, after) {
     const result = loc({ kind: 'alterCommand', commandType: 'ADD_COLUMN', column: col });
     if (after !== null && after[1] && typeof after[4] === 'string') result.afterColumn = after[4];
     return result;
   }
-  function peg$f21(ifExists, col, partition) {
+  function peg$f22(ifExists, col, partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'DROP_COLUMN', columnName: col });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f22(ifExists, col, partition) {
+  function peg$f23(ifExists, col, partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'DROP_COLUMN', columnName: col });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f23(ifExists, name, type) {
+  function peg$f24(ifExists, name, type) {
     const col = loc({ kind: 'columnDef', name, type });
     return loc({ kind: 'alterCommand', commandType: 'MODIFY_COLUMN', column: col });
   }
-  function peg$f24(ifExists, col, removeProp, modifySetReset, after) {
+  function peg$f25(ifExists, col, removeProp, modifySetReset, after) {
     const result = loc({ kind: 'alterCommand', commandType: 'MODIFY_COLUMN', column: col });
     if (modifySetReset !== null) result.columnSettingOp = modifySetReset[1];
     if (after !== null && after[1] && typeof after[4] === 'string') result.afterColumn = after[4];
     return result;
   }
-  function peg$f25(name, type, def, comment, codec, ttl) {
+  function peg$f26(name, type, def, comment, codec, ttl) {
     const result = loc({ kind: 'columnDef', name });
     if (type !== null) result.type = type[2];
     if (def !== null) { result.defaultKind = def[1].kind; if (def[1].expr) result.defaultExpr = def[1].expr; }
@@ -1226,7 +1281,7 @@ function peg$parse(input, options) {
     if (ttl !== null) result.ttl = ttl[1];
     return result;
   }
-  function peg$f26(name, type, collate, nullable1, autoIncrement, primaryKey, def, nullable2, comment, codec, stats, ttl, colSettings) {
+  function peg$f27(name, type, collate, nullable1, autoIncrement, primaryKey, def, nullable2, comment, codec, stats, ttl, colSettings) {
     const result = loc({ kind: 'columnDef', name });
     if (type !== null) result.type = type[2];
     else if (autoIncrement !== null) result.type = { name: 'INT', args: [] };
@@ -1242,27 +1297,27 @@ function peg$parse(input, options) {
     if (colSettings !== null) result.columnSettings = colSettings[1];
     return result;
   }
-  function peg$f27() {    return 'DEFAULT';  }
-  function peg$f28() {    return 'MATERIALIZED';  }
-  function peg$f29() {    return 'ALIAS';  }
-  function peg$f30() {    return 'COMMENT';  }
-  function peg$f31() {    return 'CODEC';  }
-  function peg$f32() {    return 'TTL';  }
-  function peg$f33() {    return 'SETTINGS';  }
-  function peg$f34(settings) {    return { op: 'MODIFY_SETTING', settings };  }
-  function peg$f35(names) {    return { op: 'RESET_SETTING', names };  }
-  function peg$f36(ifExists, oldName, newName) {
+  function peg$f28() {    return 'DEFAULT';  }
+  function peg$f29() {    return 'MATERIALIZED';  }
+  function peg$f30() {    return 'ALIAS';  }
+  function peg$f31() {    return 'COMMENT';  }
+  function peg$f32() {    return 'CODEC';  }
+  function peg$f33() {    return 'TTL';  }
+  function peg$f34() {    return 'SETTINGS';  }
+  function peg$f35(settings) {    return { op: 'MODIFY_SETTING', settings };  }
+  function peg$f36(names) {    return { op: 'RESET_SETTING', names };  }
+  function peg$f37(ifExists, oldName, newName) {
     return loc({ kind: 'alterCommand', commandType: 'RENAME_COLUMN', oldName, newName });
   }
-  function peg$f37(ifExists, col, comment) {
+  function peg$f38(ifExists, col, comment) {
     return loc({ kind: 'alterCommand', commandType: 'COMMENT_COLUMN', columnName: col, comment });
   }
-  function peg$f38(ifExists, col, partition) {
+  function peg$f39(ifExists, col, partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'MATERIALIZE_COLUMN', columnName: col });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f39(name, type, def, comment, codec, ttl) {
+  function peg$f40(name, type, def, comment, codec, ttl) {
     const result = loc({ kind: 'columnDef', name });
     if (type !== null) result.type = type[2];
     if (def !== null) { result.defaultKind = def[1].kind; if (def[1].expr) result.defaultExpr = def[1].expr; }
@@ -1271,95 +1326,94 @@ function peg$parse(input, options) {
     if (ttl !== null) result.ttl = ttl[1];
     return result;
   }
-  function peg$f40(name, query, projSettings) {
+  function peg$f41(name, query, projSettings) {
     const result = loc({ kind: 'projectionDef', name, query });
     if (projSettings !== null) result.projectionSettings = projSettings[9];
     return result;
   }
-  function peg$f41(name, indexExpr, indexType) {
+  function peg$f42(name, indexExpr, indexType) {
     return loc({ kind: 'projectionDef', name, indexExpr, indexType });
   }
-  function peg$f42(name, ct, expr) {
+  function peg$f43(name, ct, expr) {
     return loc({ kind: 'constraintDef', name, constraintType: ct.toUpperCase(), expr });
   }
-  function peg$f43(name, expr, indexType, n) {    return parseInt(n, 10);  }
-  function peg$f44(name, expr, indexType, gran) {
+  function peg$f44(name, expr, indexType, n) {    return parseInt(n, 10);  }
+  function peg$f45(name, expr, indexType, gran) {
     const result = loc({ kind: 'indexDef', name, expr, indexType });
     if (gran !== null) result.granularity = gran;
     return result;
   }
-  function peg$f45(head, tail) {    return head + tail.map(t => '.' + t[1]).join('');  }
-  function peg$f46(ifNotExists, idx, after) {
+  function peg$f46(head, tail) {    return head + tail.map(t => '.' + t[1]).join('');  }
+  function peg$f47(ifNotExists, idx, after) {
     const result = loc({ kind: 'alterCommand', commandType: 'ADD_INDEX', index: idx });
     if (after !== null && after[1] && typeof after[4] === 'string') result.afterIndex = after[4];
     return result;
   }
-  function peg$f47(ifExists, name, partition) {
+  function peg$f48(ifExists, name, partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'DROP_INDEX', indexName: name });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f48(ifExists, name, partition) {
+  function peg$f49(ifExists, name, partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'DROP_INDEX', indexName: name });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f49(ifExists, name, partition) {
+  function peg$f50(ifExists, name, partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'MATERIALIZE_INDEX', indexName: name });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f50(ifNotExists, proj, after) {
+  function peg$f51(ifNotExists, proj, after) {
     const result = loc({ kind: 'alterCommand', commandType: 'ADD_PROJECTION', projection: proj });
     if (after !== null) result.afterProjection = after[4];
     return result;
   }
-  function peg$f51(ifExists, name, partition) {
+  function peg$f52(ifExists, name, partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'DROP_PROJECTION', projectionName: name });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f52(ifExists, name, partition) {
+  function peg$f53(ifExists, name, partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'DROP_PROJECTION', projectionName: name });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f53(ifExists, name, partition) {
+  function peg$f54(ifExists, name, partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'MATERIALIZE_PROJECTION', projectionName: name });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f54(ifNotExists, constraint) {
+  function peg$f55(ifNotExists, constraint) {
     return loc({ kind: 'alterCommand', commandType: 'ADD_CONSTRAINT', constraint });
   }
-  function peg$f55(ifExists, name) {
+  function peg$f56(ifExists, name) {
     return loc({ kind: 'alterCommand', commandType: 'DROP_CONSTRAINT', constraintName: name });
   }
-  function peg$f56(ifNotExists, columns, types) {
+  function peg$f57(ifNotExists, columns, types) {
     return loc({ kind: 'alterCommand', commandType: 'ADD_STATISTICS', statColumns: columns, statTypes: types });
   }
-  function peg$f57(ifExists) {
+  function peg$f58(ifExists) {
     return loc({ kind: 'alterCommand', commandType: 'DROP_STATISTICS' });
   }
-  function peg$f58(ifExists, columns) {
+  function peg$f59(ifExists, columns) {
     return loc({ kind: 'alterCommand', commandType: 'DROP_STATISTICS', statColumns: columns });
   }
-  function peg$f59(ifExists, columns, types) {
+  function peg$f60(ifExists, columns, types) {
     return loc({ kind: 'alterCommand', commandType: 'MODIFY_STATISTICS', statColumns: columns, statTypes: types });
   }
-  function peg$f60(ifExists) {
+  function peg$f61(ifExists) {
     return loc({ kind: 'alterCommand', commandType: 'DROP_STATISTICS' });
   }
-  function peg$f61(ifExists, columns) {
+  function peg$f62(ifExists, columns) {
     return loc({ kind: 'alterCommand', commandType: 'DROP_STATISTICS', statColumns: columns });
   }
-  function peg$f62(ifExists) {
+  function peg$f63(ifExists) {
     return loc({ kind: 'alterCommand', commandType: 'MATERIALIZE_STATISTICS' });
   }
-  function peg$f63(ifExists, columns) {
+  function peg$f64(ifExists, columns) {
     return loc({ kind: 'alterCommand', commandType: 'MATERIALIZE_STATISTICS', statColumns: columns });
   }
-  function peg$f64(head, tail) {    return [head, ...tail.map(t => t[3])];  }
   function peg$f65(head, tail) {    return [head, ...tail.map(t => t[3])];  }
   function peg$f66(assignments, partition, where) {
     return loc({ kind: 'alterCommand', commandType: 'UPDATE', assignments, where, partition });
@@ -1389,97 +1443,101 @@ function peg$parse(input, options) {
   function peg$f75(part) {
     return loc({ kind: 'alterCommand', commandType: 'DROP_PARTITION', partition: part });
   }
-  function peg$f76(part) {
+  function peg$f76(partName) {
+    return loc({ kind: 'alterCommand', commandType: 'DROP_DETACHED_PARTITION', partName: partName });
+  }
+  function peg$f77(part) {
     return loc({ kind: 'alterCommand', commandType: 'DROP_DETACHED_PARTITION', partition: part });
   }
-  function peg$f77(partName) {
+  function peg$f78(partName) {
     return loc({ kind: 'alterCommand', commandType: 'ATTACH_PARTITION', partName: partName });
   }
-  function peg$f78(part, fromTable) {
+  function peg$f79(part, fromTable) {
     return loc({ kind: 'alterCommand', commandType: 'REPLACE_PARTITION', partition: part, fromTable: fromTable });
   }
-  function peg$f79(part, from) {
+  function peg$f80(part, from) {
     const result = loc({ kind: 'alterCommand', commandType: 'ATTACH_PARTITION', partition: part });
     if (from !== null) result.fromTable = from[4];
     return result;
   }
-  function peg$f80(part, table) {
+  function peg$f81(part, table) {
     return loc({ kind: 'alterCommand', commandType: 'REPLACE_PARTITION', partition: part, fromTable: table });
   }
-  function peg$f81(part, table) {    return { destType: 'TABLE', table };  }
-  function peg$f82(part, disk) {    return { destType: 'DISK', value: disk };  }
-  function peg$f83(part, vol) {    return { destType: 'VOLUME', value: vol };  }
-  function peg$f84(part, shard) {    return { destType: 'SHARD', value: shard };  }
-  function peg$f85(part, dest) {
+  function peg$f82(part, table) {    return { destType: 'TABLE', table };  }
+  function peg$f83(part, disk) {    return { destType: 'DISK', value: disk };  }
+  function peg$f84(part, vol) {    return { destType: 'VOLUME', value: vol };  }
+  function peg$f85(part, shard) {    return { destType: 'SHARD', value: shard };  }
+  function peg$f86(part, dest) {
     return loc({ kind: 'alterCommand', commandType: 'MOVE_PARTITION', partition: part, moveDest: dest });
   }
-  function peg$f86(part, path) {
+  function peg$f87(part, path) {
     return loc({ kind: 'alterCommand', commandType: 'FETCH_PARTITION', partition: part, fromPath: path });
   }
-  function peg$f87() {    return { partitionKind: 'all' };  }
-  function peg$f88(id) {    return { partitionKind: 'id', id };  }
-  function peg$f89(expr) {    return { partitionKind: 'expr', expr };  }
-  function peg$f90(part, withName) {
+  function peg$f88() {    return { partitionKind: 'all' };  }
+  function peg$f89(id) {    return { partitionKind: 'id', id };  }
+  function peg$f90(expr) {    return { partitionKind: 'expr', expr };  }
+  function peg$f91(part, withName) {
     return loc({ kind: 'alterCommand', commandType: 'FREEZE_PARTITION', partition: part });
   }
-  function peg$f91(withName) {
+  function peg$f92(withName) {
     return loc({ kind: 'alterCommand', commandType: 'FREEZE_ALL' });
   }
-  function peg$f92(head, tail) {
+  function peg$f93(head, tail) {
     const ttl = [head, ...tail.map(t => t[3])];
     return loc({ kind: 'alterCommand', commandType: 'MODIFY_TTL', ttl });
   }
-  function peg$f93() {
+  function peg$f94() {
     return loc({ kind: 'alterCommand', commandType: 'REMOVE_TTL' });
   }
-  function peg$f94(partition) {
+  function peg$f95(partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'MATERIALIZE_TTL' });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f95(expr) {
+  function peg$f96(expr) {
     return loc({ kind: 'alterCommand', commandType: 'MODIFY_ORDER_BY', expr });
   }
-  function peg$f96(expr) {
+  function peg$f97(expr) {
     return loc({ kind: 'alterCommand', commandType: 'MODIFY_SAMPLE_BY', expr });
   }
-  function peg$f97() {
+  function peg$f98() {
     return loc({ kind: 'alterCommand', commandType: 'REMOVE_SAMPLE_BY' });
   }
-  function peg$f98(settings) {
+  function peg$f99(settings) {
     return loc({ kind: 'alterCommand', commandType: 'MODIFY_SETTING', settings });
   }
-  function peg$f99(names) {
+  function peg$f100(names) {
     return loc({ kind: 'alterCommand', commandType: 'RESET_SETTING', settingNames: names });
   }
-  function peg$f100(head, tail) {    return [head, ...tail.map(t => t[3])];  }
   function peg$f101(query) {
     return loc({ kind: 'alterCommand', commandType: 'MODIFY_QUERY', query });
   }
   function peg$f102(comment) {
     return loc({ kind: 'alterCommand', commandType: 'MODIFY_COMMENT', comment });
   }
-  function peg$f103(partition) {
+  function peg$f103(refresh) {
+    return loc({ kind: 'alterCommand', commandType: 'MODIFY_REFRESH', refresh });
+  }
+  function peg$f104(partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'APPLY_DELETED_MASK' });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f104(partition) {
+  function peg$f105(partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'APPLY_PATCHES' });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f105(partition) {
+  function peg$f106(partition) {
     const result = loc({ kind: 'alterCommand', commandType: 'REWRITE_PARTS' });
     if (partition !== null) result.partition = partition[1];
     return result;
   }
-  function peg$f106() {    return { partitionKind: 'all' };  }
-  function peg$f107(id) {    return { partitionKind: 'id', id };  }
-  function peg$f108(expr) {    return { partitionKind: 'expr', expr };  }
-  function peg$f109(part) {    return part;  }
-  function peg$f110(id) {    return { partitionKind: 'id', id };  }
-  function peg$f111(keyword, body) {    return loc({ kind: 'system', body: (keyword + ' ' + body).trim() });  }
+  function peg$f107() {    return { partitionKind: 'all' };  }
+  function peg$f108(id) {    return { partitionKind: 'id', id };  }
+  function peg$f109(expr) {    return { partitionKind: 'expr', expr };  }
+  function peg$f110(part) {    return part;  }
+  function peg$f111(id) {    return { partitionKind: 'id', id };  }
   function peg$f112(ifExists, indexName, table) {
     return loc({ kind: 'drop', targetType: 'INDEX', table, indexName });
   }
@@ -1499,12 +1557,303 @@ function peg$parse(input, options) {
     return loc(result);
   }
   function peg$f114(body) {    return loc({ kind: 'system', body: body.trim() });  }
-  function peg$f115() {    return 'TABLE';  }
-  function peg$f116() {    return 'VIEW';  }
-  function peg$f117() {    return 'DICTIONARY';  }
-  function peg$f118() {    return 'DATABASE';  }
-  function peg$f119() {    return 'FUNCTION';  }
-  function peg$f120(withClause, target, partitionBy, columns, fromInfile, insertSettings, data) {
+  function peg$f115(ifne, table, uuid, cluster, format) {
+    const result = { kind: 'undrop', table };
+    if (ifne !== null) result.ifNotExists = true;
+    if (uuid !== null) result.uuid = uuid[3].value;
+    if (cluster !== null) result.onCluster = cluster[1];
+    if (format !== null) result.format = format[1];
+    return loc(result);
+  }
+  function peg$f116(op, elements, destination, cluster, settings, wait, format) {
+    const result = { kind: 'backup', operation: op.toUpperCase(), elements, destination };
+    if (cluster !== null) result.onCluster = cluster[1];
+    if (settings !== null) result.settings = settings[1];
+    if (wait !== null) result.wait = wait[1].toUpperCase();
+    if (format !== null) result.format = format[1];
+    return loc(result);
+  }
+  function peg$f117(exceptDbs, exceptTbls) {
+    const result = { kind: 'all' };
+    if (exceptDbs !== null) result.exceptDatabases = exceptDbs[6];
+    if (exceptTbls !== null) result.exceptTables = exceptTbls[6];
+    return [result];
+  }
+  function peg$f118(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f119(table, as) {
+    const result = { kind: 'temporaryTable', table };
+    if (as !== null) result.as = as;
+    return result;
+  }
+  function peg$f120(table, as, parts, except) {
+    const result = { kind: 'table', table };
+    if (as !== null) result.as = as;
+    if (parts !== null) result.partitions = parts[1];
+    if (except !== null) result.exceptColumns = except[1];
+    return result;
+  }
+  function peg$f121(table, as) {
+    const result = { kind: 'dictionary', table };
+    if (as !== null) result.as = as;
+    return result;
+  }
+  function peg$f122(table, as) {
+    const result = { kind: 'view', table };
+    if (as !== null) result.as = as;
+    return result;
+  }
+  function peg$f123(name, as, except) {
+    const result = { kind: 'database', name };
+    if (as !== null) result.as = as[3];
+    if (except !== null) result.exceptTables = except[6];
+    return result;
+  }
+  function peg$f124(name) {    return { kind: 'function', name };  }
+  function peg$f125(name) {    return { kind: 'namedCollection', name };  }
+  function peg$f126(table) {    return table;  }
+  function peg$f127(list) {    return list;  }
+  function peg$f128(list) {    return list;  }
+  function peg$f129(list) {    return list;  }
+  function peg$f130(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f131(name, args) {
+    const result = { name };
+    if (args !== null) result.args = args[3] || [];
+    return result;
+  }
+  function peg$f132(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f133(op, optionFor, cluster, elements) {    return { elements };  }
+  function peg$f134(op, optionFor, cluster, roles) {    return { roles };  }
+  function peg$f135(op, optionFor, cluster, body, grantees, withOpts) {
+    const result = { kind: 'grant', operation: op.toUpperCase() };
+    if (body.elements !== undefined) result.elements = body.elements;
+    else result.roles = body.roles;
+    result.grantees = grantees;
+    if (optionFor !== null) result.optionFor = optionFor[1].toUpperCase();
+    if (cluster !== null) result.onCluster = cluster[1];
+    if (withOpts.length > 0) result.withOptions = withOpts.map(w => w[4].toUpperCase());
+    return loc(result);
+  }
+  function peg$f136(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f137(privileges, target) {    return { privileges, target };  }
+  function peg$f138(head, tail) {    return [head, ...tail.map(t => t[3])].map(p => p.name);  }
+  function peg$f139(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f140(words, columns) {
+    const result = { name: words.join(' ') };
+    if (columns !== null) result.columns = columns[3];
+    return result;
+  }
+  function peg$f141(head, tail) {    return [head, ...tail.map(t => t[1])];  }
+  function peg$f142(w) {    return w;  }
+  function peg$f143(db, tbl) {    return { database: db, table: tbl };  }
+  function peg$f144(tbl) {    return { table: tbl };  }
+  function peg$f145() {    return '*';  }
+  function peg$f146(name) {    return name;  }
+  function peg$f147(chars) {    return chars.join("");  }
+  function peg$f148(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f149() {    return 'CURRENT_USER';  }
+  function peg$f150(name) {
+    return name.host !== undefined ? name.name + '@' + name.host : name.name;
+  }
+  function peg$f151(ifExists, names, cluster, clauses) {
+    const result = { kind: 'alterUser', names, clauses: clauses.map(c => c[1]) };
+    if (ifExists !== null) result.ifExists = true;
+    if (cluster !== null) result.onCluster = cluster[1];
+    return loc(result);
+  }
+  function peg$f152(to) {    return { kind: 'rename', to };  }
+  function peg$f153() {    return { kind: 'notIdentified' };  }
+  function peg$f154(auth) {    return { kind: 'identified', auth };  }
+  function peg$f155(mode, hosts) {    return { kind: 'host', mode: mode.toUpperCase(), hosts };  }
+  function peg$f156(hosts) {    return { kind: 'host', hosts };  }
+  function peg$f157() {    return { kind: 'settings', settings: 'NONE' };  }
+  function peg$f158(items) {    return { kind: 'settings', settings: items };  }
+  function peg$f159(roles) {    return { kind: 'defaultRole', roles };  }
+  function peg$f160(db) {    return { kind: 'defaultDatabase', database: db };  }
+  function peg$f161(g) {    return { kind: 'grantees', grantees: g };  }
+  function peg$f162(str) {    return { kind: 'validUntil', value: str.value };  }
+  function peg$f163(ifExists, names, cluster, rename, settings) {
+    const result = { kind: 'alterRole', names };
+    if (ifExists !== null) result.ifExists = true;
+    if (cluster !== null) result.onCluster = cluster[1];
+    if (rename !== null) result.renameTo = rename[7];
+    if (settings !== null) result.settings = settings[1];
+    return loc(result);
+  }
+  function peg$f164(ifExists, names, cluster, rename, clauses) {
+    const result = { kind: 'alterQuota', names };
+    if (ifExists !== null) result.ifExists = true;
+    if (cluster !== null) result.onCluster = cluster[1];
+    if (rename !== null) result.renameTo = rename[7];
+    const intervals = [];
+    for (const c of clauses) {
+      const clause = c[3];
+      if (clause.keyed !== undefined) result.keyed = clause.keyed;
+      if (clause.interval !== undefined) intervals.push(clause.interval);
+      if (clause.to !== undefined) result.to = clause.to;
+    }
+    if (intervals.length > 0) result.intervals = intervals;
+    return loc(result);
+  }
+  function peg$f165(hasRow, ifExists, targetsResult, clauses) {
+    const result = { kind: 'alterRowPolicy', targets: targetsResult.targets };
+    if (hasRow !== null) result.hasRowKeyword = true;
+    if (ifExists !== null) result.ifExists = true;
+    if (targetsResult.onCluster) result.onCluster = targetsResult.onCluster;
+    for (const c of clauses) {
+      const clause = c[1];
+      if (clause.renameTo !== undefined) result.renameTo = clause.renameTo;
+      if (clause.forSelect !== undefined) result.forSelect = clause.forSelect;
+      if (clause.using !== undefined) result.using = clause.using;
+      if (clause.restrictive !== undefined) result.restrictive = clause.restrictive;
+      if (clause.to !== undefined) result.to = clause.to;
+      if (clause.onCluster !== undefined) result.onCluster = clause.onCluster;
+    }
+    return loc(result);
+  }
+  function peg$f166(name) {    return { renameTo: name };  }
+  function peg$f167() {    return { forSelect: true };  }
+  function peg$f168(expr) {    return { using: expr };  }
+  function peg$f169(mode) {    return { restrictive: mode.toUpperCase() };  }
+  function peg$f170(target) {    return { to: target };  }
+  function peg$f171() {    return text();  }
+  function peg$f172(name) {    return { onCluster: name };  }
+  function peg$f173(hasSK, ifExists, names, cluster, rename, settings, to) {
+    const result = { kind: 'alterSettingsProfile', names };
+    if (hasSK !== null) result.hasSettingsKeyword = true;
+    if (ifExists !== null) result.ifExists = true;
+    if (cluster !== null) result.onCluster = cluster[1];
+    if (rename !== null) result.renameTo = rename[7];
+    if (settings !== null) result.settings = settings[1];
+    if (to !== null) result.to = to[4];
+    return loc(result);
+  }
+  function peg$f174(show, format) {
+    const result = { kind: 'show', show };
+    if (format !== null) result.format = format[1];
+    return loc(result);
+  }
+  function peg$f175(targets) {
+    return { type: 'createRowPolicy', policies: targets.targets };
+  }
+  function peg$f176(names) {
+    return { type: 'createRowPolicy', policies: names.map(name => ({ names: [name] })) };
+  }
+  function peg$f177(entity, names) {
+    return { type: 'createAccess', entity, names };
+  }
+  function peg$f178() {    return 'USER';  }
+  function peg$f179() {    return 'ROLE';  }
+  function peg$f180() {    return 'QUOTA';  }
+  function peg$f181() {    return 'SETTINGS PROFILE';  }
+  function peg$f182() {    return 'NAMED COLLECTION';  }
+  function peg$f183(extended, full) {    return 'COLUMNS';  }
+  function peg$f184(extended, full) {    return 'FIELDS';  }
+  function peg$f185(extended, full, kw, table, from, like, where, limit) {
+    const result = { type: 'columns', keyword: kw, table };
+    if (extended !== null) result.extended = true;
+    if (full !== null) result.full = true;
+    if (from !== null) result.from = from[4];
+    if (like !== null) result.like = like[1];
+    if (where !== null) result.where = where[4];
+    if (limit !== null) result.limit = limit[4];
+    return result;
+  }
+  function peg$f186(extended) {    return 'INDEXES';  }
+  function peg$f187(extended) {    return 'INDICES';  }
+  function peg$f188(extended) {    return 'INDEX';  }
+  function peg$f189(extended) {    return 'KEYS';  }
+  function peg$f190(extended, kw, table, from, where) {
+    const result = { type: 'indexes', keyword: kw, table };
+    if (extended !== null) result.extended = true;
+    if (from !== null) result.from = from[4];
+    if (where !== null) result.where = where[4];
+    return result;
+  }
+  function peg$f191(forClause, impl, final) {
+    const result = { type: 'grants' };
+    if (forClause !== null) result.for = forClause[4];
+    if (impl !== null) result.withImplicit = true;
+    if (final !== null) result.final = true;
+    return result;
+  }
+  function peg$f192(temp) {    return 'TABLES';  }
+  function peg$f193(temp) {    return 'DATABASES';  }
+  function peg$f194(temp) {    return 'DICTIONARIES';  }
+  function peg$f195(temp, objectType, from, like, where, limit, settings) {
+    const result = { type: 'listing', objectType };
+    if (temp !== null) result.temporary = true;
+    if (from !== null) result.from = from[4];
+    if (like !== null) result.like = like[1];
+    if (where !== null) result.where = where[4];
+    if (limit !== null) result.limit = limit[4];
+    if (settings !== null) result.settings = settings[1];
+    return result;
+  }
+  function peg$f196(changedPre) {
+    return { type: 'accessEntities', objectType: 'SETTINGS PROFILES' };
+  }
+  function peg$f197(changedPre, like, changedPost) {
+    const result = { type: 'accessEntities', objectType: 'SETTINGS' };
+    if (changedPre !== null || changedPost !== null) result.modifier = 'CHANGED';
+    if (like !== null) result.like = like[1];
+    return result;
+  }
+  function peg$f198() {    return { type: 'accessEntities', objectType: 'ROW POLICIES' };  }
+  function peg$f199() {    return { type: 'accessEntities', objectType: 'ROW POLICIES' };  }
+  function peg$f200() {    return { type: 'accessEntities', objectType: 'NAMED COLLECTIONS' };  }
+  function peg$f201() {    return { type: 'accessEntities', objectType: 'SETTINGS PROFILES' };  }
+  function peg$f202(like, limit) {
+    const result = { type: 'accessEntities', objectType: 'CLUSTERS' };
+    if (like !== null) result.like = like[1];
+    if (limit !== null) result.limit = limit[4];
+    return result;
+  }
+  function peg$f203(mod) {
+    const result = { type: 'accessEntities', objectType: 'ROLES' };
+    if (mod !== null) result.modifier = mod[0].toUpperCase();
+    return result;
+  }
+  function peg$f204() {    return { type: 'accessEntities', objectType: 'USERS' };  }
+  function peg$f205() {    return { type: 'accessEntities', objectType: 'QUOTAS' };  }
+  function peg$f206() {    return { type: 'accessEntities', objectType: 'WARNINGS' };  }
+  function peg$f207(name) {    return { type: 'setting', name };  }
+  function peg$f208() {    return { type: 'privileges' };  }
+  function peg$f209() {    return { type: 'engines' };  }
+  function peg$f210() {    return { type: 'merges' };  }
+  function peg$f211() {    return { type: 'access' };  }
+  function peg$f212(full) {
+    const result = { type: 'processlist' };
+    if (full !== null) result.full = true;
+    return result;
+  }
+  function peg$f213(like) {
+    const result = { type: 'functions' };
+    if (like !== null) result.like = like[1];
+    return result;
+  }
+  function peg$f214(name) {    return { type: 'cluster', name };  }
+  function peg$f215(temp) {    return 'TABLE';  }
+  function peg$f216(temp) {    return 'VIEW';  }
+  function peg$f217(temp, kw, table) {
+    const result = { type: 'objectShorthand', objectType: kw, table };
+    if (temp !== null) result.temporary = true;
+    return result;
+  }
+  function peg$f218(db) {    return { type: 'databaseShorthand', database: db };  }
+  function peg$f219(not) {    return true;  }
+  function peg$f220(not) {    return false;  }
+  function peg$f221(not, kw, pat) {
+    const result = { pattern: pat.value };
+    if (not !== null) result.not = true;
+    if (kw) result.ilike = true;
+    return result;
+  }
+  function peg$f222() {    return 'TABLE';  }
+  function peg$f223() {    return 'VIEW';  }
+  function peg$f224() {    return 'DICTIONARY';  }
+  function peg$f225() {    return 'DATABASE';  }
+  function peg$f226() {    return 'FUNCTION';  }
+  function peg$f227(withClause, target, partitionBy, columns, fromInfile, insertSettings, data) {
     const result = { kind: 'insert', target: target };
     if (withClause && withClause.items) result.with = withClause.items;
     if (partitionBy !== null) result.partitionBy = partitionBy[7];
@@ -1517,7 +1866,7 @@ function peg$parse(input, options) {
     }
     return loc(result);
   }
-  function peg$f121(target, partitionBy, columns, fromInfile, insertSettings, data) {
+  function peg$f228(target, partitionBy, columns, fromInfile, insertSettings, data) {
     const result = { kind: 'insert', target: target };
     if (partitionBy !== null) result.partitionBy = partitionBy[7];
     if (columns !== null) result.columns = columns[1];
@@ -1529,33 +1878,33 @@ function peg$parse(input, options) {
     }
     return loc(result);
   }
-  function peg$f122(path, comp) {    return comp;  }
-  function peg$f123(path, compression) {
+  function peg$f229(path, comp) {    return comp;  }
+  function peg$f230(path, compression) {
     const result = { path };
     if (compression !== null) result.compression = compression;
     return result;
   }
-  function peg$f124(func) {    return { kind: 'function', func };  }
-  function peg$f125(func) {    return { kind: 'function', func };  }
-  function peg$f126(table) {    return { kind: 'table', table };  }
-  function peg$f127(table) {    return { kind: 'table', table };  }
-  function peg$f128(name, args) {
+  function peg$f231(func) {    return { kind: 'function', func };  }
+  function peg$f232(func) {    return { kind: 'function', func };  }
+  function peg$f233(table) {    return { kind: 'table', table };  }
+  function peg$f234(table) {    return { kind: 'table', table };  }
+  function peg$f235(name, args) {
     return loc({ kind: 'tableFunctionRef', name, args: args !== null ? args : [] });
   }
-  function peg$f129(head, tail) {
+  function peg$f236(head, tail) {
     return buildCommaList(head, tail);
   }
-  function peg$f130() {    return null;  }
-  function peg$f131() {    return null;  }
-  function peg$f132(query, querySettings) {    return { query, querySettings: querySettings ? querySettings[1] : null };  }
-  function peg$f133() {    return null;  }
-  function peg$f134(head, tail) {
+  function peg$f237() {    return null;  }
+  function peg$f238() {    return null;  }
+  function peg$f239(query, querySettings) {    return { query, querySettings: querySettings ? querySettings[1] : null };  }
+  function peg$f240() {    return null;  }
+  function peg$f241(head, tail) {
     return loc({ kind: 'parallelWith', queries: [head, ...tail.map(t => t[7])] });
   }
-  function peg$f135(head, tail) {
+  function peg$f242(head, tail) {
     return loc({ kind: 'parallelWith', queries: [head, ...tail.map(t => t[7])] });
   }
-  function peg$f136(all, ifExists, database, cluster, likeClause) {
+  function peg$f243(all, ifExists, database, cluster, likeClause) {
     const result = { kind: 'truncate', targetType: 'TABLES', database };
     if (all !== null) result.allTables = true;
     if (ifExists !== null) result.ifExists = true;
@@ -1567,13 +1916,13 @@ function peg$parse(input, options) {
     }
     return loc(result);
   }
-  function peg$f137(ifExists, database, cluster) {
+  function peg$f244(ifExists, database, cluster) {
     const result = { kind: 'truncate', targetType: 'DATABASE', database };
     if (ifExists !== null) result.ifExists = true;
     if (cluster !== null) result.onCluster = cluster[1];
     return loc(result);
   }
-  function peg$f138(temp, ifExists, table, cluster, settings) {
+  function peg$f245(temp, ifExists, table, cluster, settings) {
     const result = { kind: 'truncate', targetType: 'TABLE', table };
     if (temp !== null) result.temporary = true;
     if (ifExists !== null) result.ifExists = true;
@@ -1581,7 +1930,7 @@ function peg$parse(input, options) {
     if (settings !== null) result.settings = settings[1];
     return loc(result);
   }
-  function peg$f139(table, cluster, partition, final, cleanup, dedup, settings) {
+  function peg$f246(table, cluster, partition, final, cleanup, dedup, settings) {
     const result = { kind: 'optimize', table };
     if (cluster !== null) result.onCluster = cluster[1];
     if (partition !== null) result.partition = partition;
@@ -1594,20 +1943,20 @@ function peg$parse(input, options) {
     if (settings !== null) result.settings = settings[1];
     return loc(result);
   }
-  function peg$f140(lit) {
+  function peg$f247(lit) {
     return { kind: 'id', id: lit.value };
   }
-  function peg$f141() {
+  function peg$f248() {
     return { kind: 'all' };
   }
-  function peg$f142(expr) {
+  function peg$f249(expr) {
     return { kind: 'expr', expr };
   }
-  function peg$f143(by) {
+  function peg$f250(by) {
     return { by: by };
   }
-  function peg$f144(list) {    return list;  }
-  function peg$f145(target, final, preSettings, format, postSettings) {
+  function peg$f251(list) {    return list;  }
+  function peg$f252(target, final, preSettings, format, postSettings) {
     const result = { kind: 'describe', target };
     if (final !== null) result.final = true;
     if (format !== null) result.format = format[1];
@@ -1621,13 +1970,13 @@ function peg$parse(input, options) {
     if (preSettings !== null && format !== null) result.settingsBeforeFormat = true;
     return loc(result);
   }
-  function peg$f146(query) {    return { kind: 'subquery', query };  }
-  function peg$f147(query) {
+  function peg$f253(query) {    return { kind: 'subquery', query };  }
+  function peg$f254(query) {
     return { kind: 'subquery', query };
   }
-  function peg$f148(func) {    return { kind: 'function', func };  }
-  function peg$f149(table) {    return { kind: 'table', table };  }
-  function peg$f150(target, preSettings, format, postSettings) {
+  function peg$f255(func) {    return { kind: 'function', func };  }
+  function peg$f256(table) {    return { kind: 'table', table };  }
+  function peg$f257(target, preSettings, format, postSettings) {
     const result = target;
     if (format !== null) result.format = format[1];
     const merged = [
@@ -1637,22 +1986,22 @@ function peg$parse(input, options) {
     if (merged.length > 0) result.settings = merged;
     return loc(result);
   }
-  function peg$f151(db) {
+  function peg$f258(db) {
     return { kind: 'showCreate', targetType: 'DATABASE', database: db };
   }
-  function peg$f152(targetType, table) {
+  function peg$f259(targetType, table) {
     return { kind: 'showCreate', targetType, table };
   }
-  function peg$f153(table) {
+  function peg$f260(table) {
     return { kind: 'showCreate', targetType: 'TABLE', table };
   }
-  function peg$f154(table) {
+  function peg$f261(table) {
     return { kind: 'showCreate', targetType: 'TABLE', table };
   }
-  function peg$f155() {    return 'TABLE';  }
-  function peg$f156() {    return 'VIEW';  }
-  function peg$f157() {    return 'DICTIONARY';  }
-  function peg$f158(ifExists, database, cluster, perm, sync) {
+  function peg$f262() {    return 'TABLE';  }
+  function peg$f263() {    return 'VIEW';  }
+  function peg$f264() {    return 'DICTIONARY';  }
+  function peg$f265(ifExists, database, cluster, perm, sync) {
     const result = { kind: 'detach', targetType: 'DATABASE', database };
     if (ifExists !== null) result.ifExists = true;
     if (cluster !== null) result.onCluster = cluster[1];
@@ -1660,7 +2009,7 @@ function peg$parse(input, options) {
     if (sync !== null) result.sync = true;
     return loc(result);
   }
-  function peg$f159(targetType, ifExists, table, cluster, perm, sync) {
+  function peg$f266(targetType, ifExists, table, cluster, perm, sync) {
     const result = {
       kind: 'detach',
       targetType: targetType !== null ? targetType : 'TABLE',
@@ -1672,39 +2021,39 @@ function peg$parse(input, options) {
     if (sync !== null) result.sync = true;
     return loc(result);
   }
-  function peg$f160() {    return 'TABLE';  }
-  function peg$f161() {    return 'VIEW';  }
-  function peg$f162() {    return 'DICTIONARY';  }
-  function peg$f163(table, cluster, assignments, where, settings) {
+  function peg$f267() {    return 'TABLE';  }
+  function peg$f268() {    return 'VIEW';  }
+  function peg$f269() {    return 'DICTIONARY';  }
+  function peg$f270(table, cluster, assignments, where, settings) {
     const result = { kind: 'update', table, assignments, where };
     if (cluster !== null) result.onCluster = cluster[1];
     if (settings !== null) result.settings = settings[1];
     return loc(result);
   }
-  function peg$f164(table, cluster, partition, where, settings) {
+  function peg$f271(table, cluster, partition, where, settings) {
     const result = { kind: 'delete', table, where };
     if (cluster !== null) result.onCluster = cluster[1];
     if (partition !== null) result.partition = partition;
     if (settings !== null) result.settings = settings[1];
     return loc(result);
   }
-  function peg$f165(lit) {
+  function peg$f272(lit) {
     return { kind: 'id', id: lit.value };
   }
-  function peg$f166(expr) {
+  function peg$f273(expr) {
     return { kind: 'expr', expr };
   }
-  function peg$f167(settings) {
+  function peg$f274(settings) {
     const result = { kind: 'check', targetType: 'ALL' };
     if (settings !== null) result.settings = settings[1];
     return loc(result);
   }
-  function peg$f168(database, settings) {
+  function peg$f275(database, settings) {
     const result = { kind: 'check', targetType: 'DATABASE', database };
     if (settings !== null) result.settings = settings[1];
     return loc(result);
   }
-  function peg$f169(table, partition, preSettings, format, postSettings) {
+  function peg$f276(table, partition, preSettings, format, postSettings) {
     const result = { kind: 'check', targetType: 'TABLE', table };
     if (partition !== null) result.partition = partition;
     if (format !== null) result.format = format[1];
@@ -1715,34 +2064,34 @@ function peg$parse(input, options) {
     if (mergedSettings.length > 0) result.settings = mergedSettings;
     return loc(result);
   }
-  function peg$f170(lit) {
+  function peg$f277(lit) {
     return { kind: 'id', id: lit.value };
   }
-  function peg$f171(expr) {
+  function peg$f278(expr) {
     return { kind: 'expr', expr };
   }
-  function peg$f172(lit) {
+  function peg$f279(lit) {
     return { kind: 'id', id: lit.value };
   }
-  function peg$f173(ifne, database, cluster) {
+  function peg$f280(ifne, database, cluster) {
     const result = { kind: 'attach', targetType: 'DATABASE', database };
     if (ifne !== null) result.ifNotExists = true;
     if (cluster !== null) result.onCluster = cluster[1];
     return loc(result);
   }
-  function peg$f174(targetType, ifne, table, uuid, cluster) {
+  function peg$f281(targetType, ifne, table, uuid, cluster) {
     const result = { kind: 'attach', targetType, table };
     if (ifne !== null) result.ifNotExists = true;
     if (uuid !== null) result.uuid = uuid[3].value;
     if (cluster !== null) result.onCluster = cluster[1];
     return loc(result);
   }
-  function peg$f175() {    return 'TABLE';  }
-  function peg$f176() {    return 'VIEW';  }
-  function peg$f177() {    return 'DICTIONARY';  }
-  function peg$f178() {    return true;  }
-  function peg$f179() {    return false;  }
-  function peg$f180(exchange, targetType, ifExists, head, tail, cluster, settings) {
+  function peg$f282() {    return 'TABLE';  }
+  function peg$f283() {    return 'VIEW';  }
+  function peg$f284() {    return 'DICTIONARY';  }
+  function peg$f285() {    return true;  }
+  function peg$f286() {    return false;  }
+  function peg$f287(exchange, targetType, ifExists, head, tail, cluster, settings) {
     const result = {
       kind: 'rename',
       targetType: targetType !== null ? targetType[1] : 'TABLE',
@@ -1754,17 +2103,17 @@ function peg$parse(input, options) {
     if (settings !== null) result.settings = settings[1];
     return loc(result);
   }
-  function peg$f181() {    return 'TABLE';  }
-  function peg$f182() {    return 'TABLE';  }
-  function peg$f183() {    return 'DATABASE';  }
-  function peg$f184() {    return 'DICTIONARY';  }
-  function peg$f185() {    return 'DICTIONARY';  }
-  function peg$f186(from, to) {
+  function peg$f288() {    return 'TABLE';  }
+  function peg$f289() {    return 'TABLE';  }
+  function peg$f290() {    return 'DATABASE';  }
+  function peg$f291() {    return 'DICTIONARY';  }
+  function peg$f292() {    return 'DICTIONARY';  }
+  function peg$f293(from, to) {
     return { from, to };
   }
-  function peg$f187() {    return 'QUERY';  }
-  function peg$f188() {    return 'MUTATION';  }
-  function peg$f189(target, cluster, where, mode, settings, format) {
+  function peg$f294() {    return 'QUERY';  }
+  function peg$f295() {    return 'MUTATION';  }
+  function peg$f296(target, cluster, where, mode, settings, format) {
     const result = { kind: 'kill', target, where };
     if (cluster !== null) result.onCluster = cluster[1];
     if (mode !== null) result.mode = mode[1].toUpperCase();
@@ -1772,12 +2121,12 @@ function peg$parse(input, options) {
     if (format !== null) result.format = format[1];
     return loc(result);
   }
-  function peg$f190(database, settings) {
+  function peg$f297(database, settings) {
     const result = { kind: 'exists', targetType: 'DATABASE', database };
     if (settings !== null) result.settings = settings[1];
     return loc(result);
   }
-  function peg$f191(targetType, table, settings) {
+  function peg$f298(targetType, table, settings) {
     const result = {
       kind: 'exists',
       targetType: targetType !== null ? targetType : 'TABLE',
@@ -1786,13 +2135,13 @@ function peg$parse(input, options) {
     if (settings !== null) result.settings = settings[1];
     return loc(result);
   }
-  function peg$f192() {    return 'TABLE';  }
-  function peg$f193() {    return 'VIEW';  }
-  function peg$f194() {    return 'DICTIONARY';  }
-  function peg$f195(orReplace, ifne, name, cluster, expr) {
+  function peg$f299() {    return 'TABLE';  }
+  function peg$f300() {    return 'VIEW';  }
+  function peg$f301() {    return 'DICTIONARY';  }
+  function peg$f302(orReplace, ifne, name, cluster, expr) {
     return loc({ kind: 'createFunction', name, functionExpr: expr });
   }
-  function peg$f196(orReplace, temp, ifne, table, cluster, schema, query) {
+  function peg$f303(orReplace, temp, ifne, table, cluster, schema, query) {
     const result = { kind: 'createView', table };
     if (orReplace !== null) result.orReplace = true;
     if (temp !== null) result.temporary = true;
@@ -1802,7 +2151,7 @@ function peg$parse(input, options) {
     result.asQuery = query;
     return loc(result);
   }
-  function peg$f197(leadKw, orReplace, ifne, table, uuid, cluster, refresh, toInnerUuid, toTable, schema, engine, clauses, populate, empty, query, format) {
+  function peg$f304(leadKw, orReplace, ifne, table, uuid, cluster, refresh, toInnerUuid, toTable, schema, engine, clauses, populate, empty, query, format) {
     const result = { kind: 'createMaterializedView', table };
     if (leadKw.toUpperCase() === 'ATTACH') result.attach = true;
     if (orReplace !== null) result.orReplace = true;
@@ -1819,7 +2168,7 @@ function peg$parse(input, options) {
     if (format !== null) result.format = format[1];
     return loc(result);
   }
-  function peg$f198(orReplace, ifne, name, cluster, engine, clauses, comment, format) {
+  function peg$f305(orReplace, ifne, name, cluster, engine, clauses, comment, format) {
     const result = { kind: 'createDatabase', name };
     if (orReplace !== null) result.orReplace = true;
     if (ifne !== null) result.ifNotExists = true;
@@ -1831,26 +2180,26 @@ function peg$parse(input, options) {
     if (format !== null) result.format = format[1];
     return loc(result);
   }
-  function peg$f199(unique, ifne, name, table, indexExpr, indexType, n) {    return parseInt(n, 10);  }
-  function peg$f200(unique, ifne, name, table, indexExpr, indexType, gran) {
+  function peg$f306(unique, ifne, name, table, indexExpr, indexType, n) {    return parseInt(n, 10);  }
+  function peg$f307(unique, ifne, name, table, indexExpr, indexType, gran) {
     const result = { kind: 'createIndex', table, indexName: name, indexExpr: indexExpr };
     if (indexType !== null) result.indexType = indexType[4];
     if (gran !== null) result.granularity = gran;
     return loc(result);
   }
-  function peg$f201(head, tail) {
+  function peg$f308(head, tail) {
     const exprs = [head, ...tail.map(t => t[3])];
     return exprs.length > 1 ? loc({ kind: 'functionCall', name: 'tuple', args: exprs }) : exprs[0];
   }
-  function peg$f202(expr) {    return expr;  }
-  function peg$f203(table, cluster, attrs, dictDef) {
+  function peg$f309(expr) {    return expr;  }
+  function peg$f310(table, cluster, attrs, dictDef) {
     const result = { kind: 'createDictionary', table, replace: true };
     if (cluster !== null) result.onCluster = cluster[1];
     result.dictAttrs = attrs;
     result.dictDef = dictDef;
     return loc(result);
   }
-  function peg$f204(orReplace, ifne, table, cluster, attrs, dictDef) {
+  function peg$f311(orReplace, ifne, table, cluster, attrs, dictDef) {
     const result = { kind: 'createDictionary', table };
     if (orReplace !== null) result.orReplace = true;
     if (ifne !== null) result.ifNotExists = true;
@@ -1859,14 +2208,14 @@ function peg$parse(input, options) {
     result.dictDef = dictDef;
     return loc(result);
   }
-  function peg$f205(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f206(name, type, def, expr, injective, isObjMap, hierarch, bidirect) {
+  function peg$f312(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f313(name, type, def, expr, injective, isObjMap, hierarch, bidirect) {
     const result = { name, type };
     if (def !== null) result.defaultValue = def[4];
     if (expr !== null) result.expression = expr[4];
     return result;
   }
-  function peg$f207(clauses) {
+  function peg$f314(clauses) {
     const result = {};
     for (const c of clauses) {
       const clause = c[1];
@@ -1880,56 +2229,56 @@ function peg$parse(input, options) {
     }
     return result;
   }
-  function peg$f208(head, tail) {
+  function peg$f315(head, tail) {
     return { primaryKey: [head, ...tail.map(t => t[3])] };
   }
-  function peg$f209(name, pairs) {
+  function peg$f316(name, pairs) {
     return { source: { name: name.toLowerCase(), pairs: pairs || [] } };
   }
-  function peg$f210(items) {
+  function peg$f317(items) {
     return { lifetime: items };
   }
-  function peg$f211(val) {
+  function peg$f318(val) {
     return { lifetime: { value: parseInt(val, 10) } };
   }
-  function peg$f212(name, args) {
+  function peg$f319(name, args) {
     return { layout: { name: name.toUpperCase(), pairs: args !== null ? (args[3] || []) : [] } };
   }
-  function peg$f213(items) {
+  function peg$f320(items) {
     return { range: items };
   }
-  function peg$f214(items) {
+  function peg$f321(items) {
     return { settings: items };
   }
-  function peg$f215(items) {
+  function peg$f322(items) {
     return { settings: items || [] };
   }
-  function peg$f216(str) {
+  function peg$f323(str) {
     return { comment: str.value };
   }
-  function peg$f217(head, tail) {
+  function peg$f324(head, tail) {
     const result = {};
     const items = [head, ...tail.map(t => t[1])];
     for (const item of items) Object.assign(result, item);
     return result;
   }
-  function peg$f218(val) {    return { min: parseInt(val, 10) };  }
-  function peg$f219(val) {    return { max: parseInt(val, 10) };  }
-  function peg$f220(head, tail) {    return [head, ...tail.map(t => t[1])];  }
-  function peg$f221(name, value) {    return { name, value };  }
-  function peg$f222(name, pairs) {    return { name, value: pairs };  }
-  function peg$f223(name, value) {    return { name, value: loc({ kind: 'literal', type: 'String', value: value }) };  }
-  function peg$f224(head, tail) {    return [head, ...tail.map(t => t[1])];  }
-  function peg$f225(name, type) {    return { name, type };  }
-  function peg$f226(expr, dir) {    return expr;  }
-  function peg$f227(orReplace, ifne, name, parent, settings) {
+  function peg$f325(val) {    return { min: parseInt(val, 10) };  }
+  function peg$f326(val) {    return { max: parseInt(val, 10) };  }
+  function peg$f327(head, tail) {    return [head, ...tail.map(t => t[1])];  }
+  function peg$f328(name, value) {    return { name, value };  }
+  function peg$f329(name, pairs) {    return { name, value: pairs };  }
+  function peg$f330(name, value) {    return { name, value: loc({ kind: 'literal', type: 'String', value: value }) };  }
+  function peg$f331(head, tail) {    return [head, ...tail.map(t => t[1])];  }
+  function peg$f332(name, type) {    return { name, type };  }
+  function peg$f333(expr, dir) {    return expr;  }
+  function peg$f334(orReplace, ifne, name, parent, settings) {
     const result = { kind: 'createWorkload', name };
     if (orReplace !== null) result.orReplace = true;
     if (ifne !== null) result.ifNotExists = true;
     if (parent !== null) result.parentWorkload = parent[4];
     return loc(result);
   }
-  function peg$f228(orReplacePre, ifne, orReplacePost, names, clauses) {
+  function peg$f335(orReplacePre, ifne, orReplacePost, names, clauses) {
     const result = { kind: 'createUser', names };
     if (orReplacePre !== null || orReplacePost !== null) result.orReplace = true;
     if (ifne !== null) result.ifNotExists = true;
@@ -1946,48 +2295,51 @@ function peg$parse(input, options) {
     }
     return loc(result);
   }
-  function peg$f229() {    return { auth: [{}] };  }
-  function peg$f230(auth) {    return { auth };  }
-  function peg$f231(items) {    return { host: items };  }
-  function peg$f232() {    return { settings: 'NONE' };  }
-  function peg$f233(items) {    return { settings: items };  }
-  function peg$f234(roles) {    return { defaultRole: roles };  }
-  function peg$f235(db) {    return { defaultDatabase: db };  }
-  function peg$f236(target) {    return { grantees: target };  }
-  function peg$f237(str) {    return { validUntil: str.value };  }
-  function peg$f238() {    return text();  }
-  function peg$f239(name) {    return { onCluster: name };  }
-  function peg$f240(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f241(name, chars) {    return "'" + chars + "'";  }
-  function peg$f242(name, host) {    return host;  }
-  function peg$f243(name, host) {
+  function peg$f336() {    return { auth: [{}] };  }
+  function peg$f337(auth) {    return { auth };  }
+  function peg$f338(items) {    return { host: items };  }
+  function peg$f339() {    return { settings: 'NONE' };  }
+  function peg$f340(items) {    return { settings: items };  }
+  function peg$f341(roles) {    return { defaultRole: roles };  }
+  function peg$f342(db) {    return { defaultDatabase: db };  }
+  function peg$f343(target) {    return { grantees: target };  }
+  function peg$f344(str) {    return { validUntil: str.value };  }
+  function peg$f345() {    return text();  }
+  function peg$f346(name) {    return { onCluster: name };  }
+  function peg$f347(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f348(name, chars) {    return "'" + chars + "'";  }
+  function peg$f349(name, host) {    return host;  }
+  function peg$f350(name, host) {
     const result = { name };
     if (host !== null) result.host = host;
     return result;
   }
-  function peg$f244(body) {    return '{' + body + '}';  }
-  function peg$f245(chars) {    return "'" + chars.join("") + "'";  }
-  function peg$f246() {    return "'";  }
-  function peg$f247() {    return "'";  }
-  function peg$f248() {    return "\\";  }
-  function peg$f249(c) {    return c;  }
-  function peg$f250(keys) {
+  function peg$f351(body) {    return '{' + body + '}';  }
+  function peg$f352(chars) {    return "'" + chars.join("") + "'";  }
+  function peg$f353() {    return "'";  }
+  function peg$f354() {    return "'";  }
+  function peg$f355() {    return "\\";  }
+  function peg$f356(c) {    return c;  }
+  function peg$f357(keys) {
     return [{ sshKeys: keys }];
   }
-  function peg$f251(head, tail) {
+  function peg$f358(head, tail) {
     return [head, ...tail.map(t => t[3])];
   }
-  function peg$f252(secret) {    return secret;  }
-  function peg$f253() {    return {};  }
-  function peg$f254(secret) {    return secret;  }
-  function peg$f255(secret) {    return secret;  }
-  function peg$f256(str) {    return { secret: str };  }
-  function peg$f257(str) {    return { secret: str };  }
-  function peg$f258(str) {    return { secret: str };  }
-  function peg$f259(str) {    return str.value;  }
-  function peg$f260(body) {    return '{' + body + '}';  }
-  function peg$f261(head, tail) {    return 1 + tail.length;  }
-  function peg$f262(head, tail) {
+  function peg$f359(secret) {    return secret;  }
+  function peg$f360() {    return {};  }
+  function peg$f361(secret) {    return secret;  }
+  function peg$f362(secret) {    return secret;  }
+  function peg$f363(str) {    return { secret: str };  }
+  function peg$f364(str) {    return { secret: str };  }
+  function peg$f365(str) {    return { secret: str };  }
+  function peg$f366(str) {    return str.value;  }
+  function peg$f367(body) {    return '{' + body + '}';  }
+  function peg$f368(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f369(key, type) {
+    return { key: key.value, type: type.value };
+  }
+  function peg$f370(head, tail) {
     const result = [];
     for (const items of [head, ...tail.map(t => t[3])]) {
       if (Array.isArray(items)) result.push(...items);
@@ -1995,20 +2347,20 @@ function peg$parse(input, options) {
     }
     return result;
   }
-  function peg$f263() {    return { kind: 'any' };  }
-  function peg$f264() {    return { kind: 'none' };  }
-  function peg$f265() {    return { kind: 'local' };  }
-  function peg$f266(str) {    return { kind: 'name', value: str.value };  }
-  function peg$f267(str) {    return { kind: 'regexp', value: str.value };  }
-  function peg$f268(strs) {    return strs.map(s => ({ kind: 'like', value: s }));  }
-  function peg$f269(strs) {    return strs.map(s => ({ kind: 'ip', value: s }));  }
-  function peg$f270(head, tail) {    return [head.value, ...tail.map(t => t[3].value)];  }
-  function peg$f271(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f272() {    return text();  }
-  function peg$f273(name) {    return { kind: 'profile', name };  }
-  function peg$f274() {    return text();  }
-  function peg$f275(name) {    return { kind: 'inherit', name };  }
-  function peg$f276(name, val, min, max, mod) {
+  function peg$f371() {    return { kind: 'any' };  }
+  function peg$f372() {    return { kind: 'none' };  }
+  function peg$f373() {    return { kind: 'local' };  }
+  function peg$f374(strs) {    return strs.map(s => ({ kind: 'name', value: s }));  }
+  function peg$f375(strs) {    return strs.map(s => ({ kind: 'regexp', value: s }));  }
+  function peg$f376(strs) {    return strs.map(s => ({ kind: 'like', value: s }));  }
+  function peg$f377(strs) {    return strs.map(s => ({ kind: 'ip', value: s }));  }
+  function peg$f378(head, tail) {    return [head.value, ...tail.map(t => t[3].value)];  }
+  function peg$f379(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f380() {    return text();  }
+  function peg$f381(name) {    return { kind: 'profile', name };  }
+  function peg$f382() {    return text();  }
+  function peg$f383(name) {    return { kind: 'inherit', name };  }
+  function peg$f384(name, val, min, max, mod) {
     const result = { kind: 'setting', name };
     if (val !== null) result.value = val[3];
     if (min !== null) result.min = min[5];
@@ -2016,17 +2368,17 @@ function peg$parse(input, options) {
     if (mod !== null) result.modifier = mod[1].toUpperCase();
     return result;
   }
-  function peg$f277(head, tail) {    return tail.length > 0 ? head + tail.map(t => '.' + t[1]).join('') : head;  }
-  function peg$f278(orReplace, ifne, names, settings) {
+  function peg$f385(head, tail) {    return tail.length > 0 ? head + tail.map(t => '.' + t[1]).join('') : head;  }
+  function peg$f386(orReplace, ifne, names, settings) {
     const result = { kind: 'createRole', names };
     if (orReplace !== null) result.orReplace = true;
     if (ifne !== null) result.ifNotExists = true;
     if (settings !== null) result.settings = settings[1];
     return loc(result);
   }
-  function peg$f279() {    return 'NONE';  }
-  function peg$f280(items) {    return items;  }
-  function peg$f281(orReplacePre, hasRow, orReplacePost, ifne, targetsResult, clauses) {
+  function peg$f387() {    return 'NONE';  }
+  function peg$f388(items) {    return items;  }
+  function peg$f389(orReplacePre, hasRow, orReplacePost, ifne, targetsResult, clauses) {
     const result = { kind: 'createRowPolicy', targets: targetsResult.targets };
     if (orReplacePre !== null || orReplacePost !== null) result.orReplace = true;
     if (hasRow !== null) result.hasRowKeyword = true;
@@ -2041,7 +2393,7 @@ function peg$parse(input, options) {
     }
     return loc(result);
   }
-  function peg$f282(head, tail) {
+  function peg$f390(head, tail) {
     const result = { targets: [], onCluster: null };
     for (const target of [head, ...tail.map(t => t[3])]) {
       if (target.onCluster) result.onCluster = target.onCluster;
@@ -2051,27 +2403,27 @@ function peg$parse(input, options) {
     }
     return result;
   }
-  function peg$f283(names, cluster, tables) {
+  function peg$f391(names, cluster, tables) {
     const result = { names, tables };
     if (cluster !== null) result.onCluster = cluster[1];
     return result;
   }
-  function peg$f284(head, tail) {    return [head, ...tail.map(t => t[4])];  }
-  function peg$f285(db) {    return '*';  }
-  function peg$f286(db, table) {
+  function peg$f392(head, tail) {    return [head, ...tail.map(t => t[4])];  }
+  function peg$f393(db) {    return '*';  }
+  function peg$f394(db, table) {
     return loc({ kind: 'tableRef', database: db, table: table });
   }
-  function peg$f287(table) {
+  function peg$f395(table) {
     return loc({ kind: 'tableRef', table: table });
   }
-  function peg$f288(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f289() {    return {};  }
-  function peg$f290(expr) {    return { using: expr };  }
-  function peg$f291(mode) {    return { restrictive: mode.toUpperCase() };  }
-  function peg$f292(target) {    return { to: target };  }
-  function peg$f293() {    return text();  }
-  function peg$f294(name) {    return { onCluster: name };  }
-  function peg$f295(orReplace, ifne, names, clauses) {
+  function peg$f396(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f397() {    return {};  }
+  function peg$f398(expr) {    return { using: expr };  }
+  function peg$f399(mode) {    return { restrictive: mode.toUpperCase() };  }
+  function peg$f400(target) {    return { to: target };  }
+  function peg$f401() {    return text();  }
+  function peg$f402(name) {    return { onCluster: name };  }
+  function peg$f403(orReplace, ifne, names, clauses) {
     const result = { kind: 'createQuota', names };
     if (orReplace !== null) result.orReplace = true;
     if (ifne !== null) result.ifNotExists = true;
@@ -2085,14 +2437,14 @@ function peg$parse(input, options) {
     if (intervals.length > 0) result.intervals = intervals;
     return loc(result);
   }
-  function peg$f296(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f297(chars) {    return "'" + chars.join("") + "'";  }
-  function peg$f298(target) {    return { to: target };  }
-  function peg$f299() {    return { keyed: { notKeyed: true } };  }
-  function peg$f300(keys) {    return { keyed: { keys } };  }
-  function peg$f301(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f302() {    return text();  }
-  function peg$f303(randomized, duration, unit, body) {
+  function peg$f404(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f405(chars) {    return "'" + chars.join("") + "'";  }
+  function peg$f406(target) {    return { to: target };  }
+  function peg$f407() {    return { keyed: { notKeyed: true } };  }
+  function peg$f408(keys) {    return { keyed: { keys } };  }
+  function peg$f409(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f410() {    return text();  }
+  function peg$f411(randomized, duration, unit, body) {
     const result = { duration, unit: unit.toUpperCase() };
     if (randomized !== null) result.randomized = true;
     if (body !== null) {
@@ -2103,17 +2455,17 @@ function peg$parse(input, options) {
     }
     return { interval: result };
   }
-  function peg$f304() {    return text().replace(/s$/i, '');  }
-  function peg$f305() {    return { trackingOnly: true };  }
-  function peg$f306() {    return { noLimits: true };  }
-  function peg$f307(limits) {    return { limits };  }
-  function peg$f308(head, tail) {    return [head, ...tail.map(t => t[4])];  }
-  function peg$f309(name, value) {    return { name: name.toUpperCase(), value };  }
-  function peg$f310(name, value) {    return { name: name.toUpperCase(), value };  }
-  function peg$f311(name, value) {    return { name: name.toUpperCase(), value };  }
-  function peg$f312(name, value) {    return { name: name.toUpperCase(), value };  }
-  function peg$f313() {    return text().toUpperCase().replace(/ /g, '_');  }
-  function peg$f314(orReplacePre, hasSK, orReplacePost, ifne, names, settings, to) {
+  function peg$f412() {    return text().replace(/s$/i, '');  }
+  function peg$f413() {    return { trackingOnly: true };  }
+  function peg$f414() {    return { noLimits: true };  }
+  function peg$f415(limits) {    return { limits };  }
+  function peg$f416(head, tail) {    return [head, ...tail.map(t => t[4])];  }
+  function peg$f417(name, value) {    return { name: name.toUpperCase(), value };  }
+  function peg$f418(name, value) {    return { name: name.toUpperCase(), value };  }
+  function peg$f419(name, value) {    return { name: name.toUpperCase(), value };  }
+  function peg$f420(name, value) {    return { name: name.toUpperCase(), value };  }
+  function peg$f421() {    return text().toUpperCase().replace(/ /g, '_');  }
+  function peg$f422(orReplacePre, hasSK, orReplacePost, ifne, names, settings, to) {
     const result = { kind: 'createSettingsProfile', names };
     if (orReplacePre !== null || orReplacePost !== null) result.orReplace = true;
     if (hasSK !== null) result.hasSettingsKeyword = true;
@@ -2122,32 +2474,32 @@ function peg$parse(input, options) {
     if (to !== null) result.to = to[4];
     return loc(result);
   }
-  function peg$f315(orReplace, ifne, name, cluster, items) {
+  function peg$f423(orReplace, ifne, name, cluster, items) {
     const result = { kind: 'createNamedCollection', name, items };
     if (orReplace !== null) result.orReplace = true;
     if (ifne !== null) result.ifNotExists = true;
     if (cluster !== null) result.onCluster = cluster[1];
     return loc(result);
   }
-  function peg$f316(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f317(key, value) {    return { key, value };  }
-  function peg$f318(orReplace, ifne, name, specs) {
+  function peg$f424(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f425(key, value) {    return { key, value };  }
+  function peg$f426(orReplace, ifne, name, specs) {
     const result = { kind: 'createResource', name, specs };
     if (orReplace !== null) result.orReplace = true;
     if (ifne !== null) result.ifNotExists = true;
     return loc(result);
   }
-  function peg$f319(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f320(operation, resourceType, resourceName) {
+  function peg$f427(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f428(operation, resourceType, resourceName) {
     return { operation: operation.toUpperCase(), resourceType: resourceType.toUpperCase(), resourceName };
   }
-  function peg$f321(body) {
+  function peg$f429(body) {
     return loc({ kind: 'createWindowView', rawBody: body.trim() });
   }
-  function peg$f322(body) {
+  function peg$f430(body) {
     return loc({ kind: 'createLiveView', rawBody: body.trim() });
   }
-  function peg$f323(header, fromPath, body, format) {
+  function peg$f431(header, fromPath, body, format) {
     const result = { ...header, ...body };
     if (fromPath !== null) result.attachFromPath = fromPath[4].value;
     if (format !== null) result.format = format[1];
@@ -2158,13 +2510,13 @@ function peg$parse(input, options) {
     delete result._columnPrimaryKeys;
     return loc(result);
   }
-  function peg$f324(temp, table, cluster) {
+  function peg$f432(temp, table, cluster) {
     const result = { kind: 'createTable', replace: true, table };
     if (temp !== null) result.temporary = true;
     if (cluster !== null) result.onCluster = cluster[1];
     return result;
   }
-  function peg$f325(leadKw, orReplace, temp, ifne, table, cluster) {
+  function peg$f433(leadKw, orReplace, temp, ifne, table, cluster) {
     const result = { kind: 'createTable', table };
     if (leadKw.toUpperCase() === 'ATTACH') result.attach = true;
     if (orReplace !== null) result.orReplace = true;
@@ -2173,77 +2525,77 @@ function peg$parse(input, options) {
     if (cluster !== null) result.onCluster = cluster[1];
     return result;
   }
-  function peg$f326() {    return text();  }
-  function peg$f327(name) {    return name;  }
-  function peg$f328(body) {
+  function peg$f434() {    return text();  }
+  function peg$f435(name) {    return name;  }
+  function peg$f436(body) {
     return body.trim();
   }
-  function peg$f329(asTable, engine, clauses) {
+  function peg$f437(asTable, engine, clauses) {
     const result = { clone: true, asTable };
     if (engine !== null) result.engine = engine[1];
     Object.assign(result, clauses);
     return result;
   }
-  function peg$f330(body) {    return body;  }
-  function peg$f331(schema, engine, clauses, asQuery) {
+  function peg$f438(body) {    return body;  }
+  function peg$f439(schema, engine, clauses, asQuery) {
     const result = { ...schema, engine };
     Object.assign(result, clauses);
     if (asQuery !== null) result.asQuery = asQuery[3];
     return result;
   }
-  function peg$f332(schema, clauses, name, args) {
+  function peg$f440(schema, clauses, name, args) {
     const result = { ...schema, asTableFunction: { name, args: args || [] } };
     Object.assign(result, clauses);
     return result;
   }
-  function peg$f333(schema, clauses, empty, asQuery) {
+  function peg$f441(schema, clauses, empty, asQuery) {
     const result = { ...schema };
     Object.assign(result, clauses);
     if (empty !== null) result.empty = true;
     if (asQuery !== null) result.asQuery = asQuery[4];
     return result;
   }
-  function peg$f334(engine, clauses, empty, asQuery) {
+  function peg$f442(engine, clauses, empty, asQuery) {
     const result = { engine, asQuery };
     Object.assign(result, clauses);
     if (empty !== null) result.empty = true;
     return result;
   }
-  function peg$f335(engine, clauses, asTable) {
+  function peg$f443(engine, clauses, asTable) {
     const result = { engine, asTable };
     Object.assign(result, clauses);
     return result;
   }
-  function peg$f336(engine, clauses) {
+  function peg$f444(engine, clauses) {
     const result = { engine };
     Object.assign(result, clauses);
     return result;
   }
-  function peg$f337(clauses, asQuery) {
+  function peg$f445(clauses, asQuery) {
     const result = { asQuery };
     Object.assign(result, clauses);
     return result;
   }
-  function peg$f338(asTable) {
+  function peg$f446(asTable) {
     return { empty: true, asTable };
   }
-  function peg$f339(asQuery) {
+  function peg$f447(asQuery) {
     return { empty: true, asQuery };
   }
-  function peg$f340(asQuery) {
+  function peg$f448(asQuery) {
     return { asQuery };
   }
-  function peg$f341(name, args) {
+  function peg$f449(name, args) {
     const result = { asTableFunction: { name, args: args || [] } };
     return result;
   }
-  function peg$f342(asTable, engine, clauses) {
+  function peg$f450(asTable, engine, clauses) {
     const result = { asTable };
     if (engine !== null) result.engine = engine[1];
     Object.assign(result, clauses);
     return result;
   }
-  function peg$f343(elements) {
+  function peg$f451(elements) {
     // Separate primary key from other elements
     const tableElements = [];
     let primaryKeyInSchema = null;
@@ -2264,13 +2616,13 @@ function peg$parse(input, options) {
     if (columnPrimaryKeys.length > 0) result._columnPrimaryKeys = columnPrimaryKeys;
     return result;
   }
-  function peg$f344(head, tail, trailing_comma) {
+  function peg$f452(head, tail, trailing_comma) {
     return [head, ...tail.map(t => t[3])];
   }
-  function peg$f345(name, indexExpr, indexType) {
+  function peg$f453(name, indexExpr, indexType) {
     return loc({ kind: 'projectionDef', name, indexExpr, indexType });
   }
-  function peg$f346(name, type, collate, nullable1, autoIncrement, primaryKey, def, nullable2, comment, codec, stats, ttl, colSettings) {
+  function peg$f454(name, type, collate, nullable1, autoIncrement, primaryKey, def, nullable2, comment, codec, stats, ttl, colSettings) {
     const result = loc({ kind: 'columnDef', name });
     if (type !== null) result.type = type[2];
     else if (autoIncrement !== null) result.type = { name: 'INT', args: [] };
@@ -2286,86 +2638,86 @@ function peg$parse(input, options) {
     if (colSettings !== null) result.columnSettings = colSettings[1];
     return result;
   }
-  function peg$f347() {    return 'NOT NULL';  }
-  function peg$f348() {    return 'NULL';  }
-  function peg$f349(expr) {    return { kind: 'DEFAULT', expr };  }
-  function peg$f350(expr) {    return { kind: 'MATERIALIZED', expr };  }
-  function peg$f351(expr) {    return { kind: 'ALIAS', expr };  }
-  function peg$f352(expr) {
+  function peg$f455() {    return 'NOT NULL';  }
+  function peg$f456() {    return 'NULL';  }
+  function peg$f457(expr) {    return { kind: 'DEFAULT', expr };  }
+  function peg$f458(expr) {    return { kind: 'MATERIALIZED', expr };  }
+  function peg$f459(expr) {    return { kind: 'ALIAS', expr };  }
+  function peg$f460(expr) {
     const result = { kind: 'EPHEMERAL' };
     if (expr !== null) result.expr = expr[2];
     return result;
   }
-  function peg$f353(str) {    return str.value;  }
-  function peg$f354(items) {    return items;  }
-  function peg$f355(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f356(name, args) {
+  function peg$f461(str) {    return str.value;  }
+  function peg$f462(items) {    return items;  }
+  function peg$f463(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f464(name, args) {
     const result = { name };
     if (args !== null) result.args = args[3] || [];
     return result;
   }
-  function peg$f357(name, args) {
+  function peg$f465(name, args) {
     const result = { name };
     if (args !== null) result.args = args[3] || [];
     return result;
   }
-  function peg$f358(name, args) {
+  function peg$f466(name, args) {
     const result = { name };
     if (args !== null) result.args = args[3] || [];
     return result;
   }
-  function peg$f359(items) {    return items;  }
-  function peg$f360(expr) {    return expr;  }
-  function peg$f361(head, tail) {
+  function peg$f467(items) {    return items;  }
+  function peg$f468(expr) {    return expr;  }
+  function peg$f469(head, tail) {
     return [head, ...tail.map(t => t[3])];
   }
-  function peg$f362(name, val) {
+  function peg$f470(name, val) {
     return { name, value: val };
   }
-  function peg$f363(name, ct, expr) {
+  function peg$f471(name, ct, expr) {
     return loc({ kind: 'constraintDef', name, constraintType: ct.toUpperCase(), expr });
   }
-  function peg$f364(cols, table, refCols, actions) {
+  function peg$f472(cols, table, refCols, actions) {
     return loc({ kind: 'foreignKeyDef', columns: cols, refTable: table, refColumns: refCols });
   }
-  function peg$f365(name, expr, indexType, n) {    return parseInt(n, 10);  }
-  function peg$f366(name, expr, indexType, gran) {
+  function peg$f473(name, expr, indexType, n) {    return parseInt(n, 10);  }
+  function peg$f474(name, expr, indexType, gran) {
     const result = loc({ kind: 'indexDef', name, expr, indexType });
     if (gran !== null) result.granularity = gran;
     return result;
   }
-  function peg$f367(head, tail) {
+  function peg$f475(head, tail) {
     if (tail.length === 0) return head;
     return loc({ kind: 'functionCall', name: 'tuple', args: [head, ...tail.map(t => t[3])] });
   }
-  function peg$f368(name, args) {
+  function peg$f476(name, args) {
     const result = { name };
     if (args !== null) result.args = args[3] || [];
     return result;
   }
-  function peg$f369(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f370(name, query, projSettings) {
+  function peg$f477(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f478(name, query, projSettings) {
     const result = loc({ kind: 'projectionDef', name, query });
     if (projSettings !== null) result.projectionSettings = projSettings[9];
     return result;
   }
-  function peg$f371(exprs) {
+  function peg$f479(exprs) {
     return { _primaryKey: exprs };
   }
-  function peg$f372() {    return [];  }
-  function peg$f373(head, tail) {
+  function peg$f480() {    return [];  }
+  function peg$f481(head, tail) {
     return [head, ...tail.map(t => t[3])];
   }
-  function peg$f374(expr) {    return [expr];  }
-  function peg$f375(name, args) {
+  function peg$f482(expr) {    return [expr];  }
+  function peg$f483(name, args) {
     const result = { name };
     if (args !== null) result.args = args[3] !== null ? args[3] : [];
     return result;
   }
-  function peg$f376(head, tail) {
+  function peg$f484(head, tail) {
     return [head, ...tail.map(t => t[3])];
   }
-  function peg$f377(clauses) {
+  function peg$f485(clauses) {
     const result = {};
     let sawOrdering = false; // true after ORDER BY or PRIMARY KEY
     let sawComment = false;
@@ -2384,54 +2736,54 @@ function peg$parse(input, options) {
     }
     return result;
   }
-  function peg$f378(c) {    return { orderBy: c };  }
-  function peg$f379(c) {    return { partitionBy: c };  }
-  function peg$f380(c) {    return { primaryKey: c };  }
-  function peg$f381(c) {    return { sampleBy: c };  }
-  function peg$f382(c) {    return { ttl: c };  }
-  function peg$f383(c) {    return { settings: c };  }
-  function peg$f384(c) {    return { comment: c };  }
-  function peg$f385(head, tail) {
+  function peg$f486(c) {    return { orderBy: c };  }
+  function peg$f487(c) {    return { partitionBy: c };  }
+  function peg$f488(c) {    return { primaryKey: c };  }
+  function peg$f489(c) {    return { sampleBy: c };  }
+  function peg$f490(c) {    return { ttl: c };  }
+  function peg$f491(c) {    return { settings: c };  }
+  function peg$f492(c) {    return { comment: c };  }
+  function peg$f493(head, tail) {
     const items = [head, ...tail.map(t => t[3])];
     items._parenthesized = true;
     return items;
   }
-  function peg$f386(head, tail) {
+  function peg$f494(head, tail) {
     return [head, ...tail.map(t => t[3])];
   }
-  function peg$f387(expr, dir) {    return { expr, dir: dir ? dir[1].toUpperCase() : undefined };  }
-  function peg$f388() {
+  function peg$f495(expr, dir) {    return { expr, dir: dir ? dir[1].toUpperCase() : undefined };  }
+  function peg$f496() {
     return loc({ kind: 'functionCall', name: 'tuple', args: [] });
   }
-  function peg$f389(expr) {    return expr;  }
-  function peg$f390() {
+  function peg$f497(expr) {    return expr;  }
+  function peg$f498() {
     return [];
   }
-  function peg$f391(head, tail) {
+  function peg$f499(head, tail) {
     return [head, ...tail.map(t => t[3])];
   }
-  function peg$f392(expr) {
+  function peg$f500(expr) {
     return [expr];
   }
-  function peg$f393(expr) {    return expr;  }
-  function peg$f394(head, tail) {
+  function peg$f501(expr) {    return expr;  }
+  function peg$f502(head, tail) {
     return [head, ...tail.map(t => t[3])];
   }
-  function peg$f395(expr, suffix) {
+  function peg$f503(expr, suffix) {
     const item = { expr };
     if (suffix !== null && suffix[1].where) item.where = suffix[1].where;
     return item;
   }
-  function peg$f396(w) {    return w !== null ? { where: w[4] } : {};  }
-  function peg$f397() {    return {};  }
-  function peg$f398() {    return {};  }
-  function peg$f399(w) {    return { where: w };  }
-  function peg$f400() {    return {};  }
-  function peg$f401(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f402(head, tail) {    return [head, ...tail.map(t => t[3])];  }
-  function peg$f403(name, value) {    return { name, value };  }
-  function peg$f404(str) {    return str.value;  }
-  function peg$f405(type, settings, query, format, postSettings) {
+  function peg$f504(w) {    return w !== null ? { where: w[4] } : {};  }
+  function peg$f505() {    return {};  }
+  function peg$f506() {    return {};  }
+  function peg$f507(w) {    return { where: w };  }
+  function peg$f508() {    return {};  }
+  function peg$f509(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f510(head, tail) {    return [head, ...tail.map(t => t[3])];  }
+  function peg$f511(name, value) {    return { name, value };  }
+  function peg$f512(str) {    return str.value;  }
+  function peg$f513(type, settings, query, format, postSettings) {
     const result = loc({ kind: 'explain' });
     if (type !== null) result.explainType = type;
     if (settings !== null && settings.length > 0) result.settings = settings;
@@ -2440,24 +2792,24 @@ function peg$parse(input, options) {
     if (postSettings !== null) result.postFormatSettings = postSettings[1];
     return result;
   }
-  function peg$f406() {    return 'QUERY TREE';  }
-  function peg$f407() {    return 'TABLE OVERRIDE';  }
-  function peg$f408() {    return 'CURRENT TRANSACTION';  }
-  function peg$f409() {    return 'AST';  }
-  function peg$f410() {    return 'SYNTAX';  }
-  function peg$f411() {    return 'PLAN';  }
-  function peg$f412() {    return 'PIPELINE';  }
-  function peg$f413() {    return 'ESTIMATE';  }
-  function peg$f414(head, tail) {
+  function peg$f514() {    return 'QUERY TREE';  }
+  function peg$f515() {    return 'TABLE OVERRIDE';  }
+  function peg$f516() {    return 'CURRENT TRANSACTION';  }
+  function peg$f517() {    return 'AST';  }
+  function peg$f518() {    return 'SYNTAX';  }
+  function peg$f519() {    return 'PLAN';  }
+  function peg$f520() {    return 'PIPELINE';  }
+  function peg$f521() {    return 'ESTIMATE';  }
+  function peg$f522(head, tail) {
     return [head, ...tail.map((t) => t[3])];
   }
-  function peg$f415(name, value) {
+  function peg$f523(name, value) {
     return { name, value };
   }
-  function peg$f416(name) {    return name;  }
-  function peg$f417(chars) {    return chars;  }
-  function peg$f418(chars) {    return chars.join('');  }
-  function peg$f419(head, tail) {
+  function peg$f524(name) {    return name;  }
+  function peg$f525(chars) {    return chars;  }
+  function peg$f526(chars) {    return chars.join('');  }
+  function peg$f527(head, tail) {
     if (tail.length === 0) return head;
     let result = head;
     for (const t of tail) {
@@ -2479,7 +2831,7 @@ function peg$parse(input, options) {
     }
     return result;
   }
-  function peg$f420(head, tail) {
+  function peg$f528(head, tail) {
     if (tail.length === 0) return head;
     let result = head;
     for (const t of tail) {
@@ -2487,13 +2839,13 @@ function peg$parse(input, options) {
     }
     return result;
   }
-  function peg$f421(mode) {    return mode === 'DISTINCT' ? 'UNION DISTINCT' : 'UNION';  }
-  function peg$f422() {    return 'EXCEPT';  }
-  function peg$f423() {    return 'INTERSECT';  }
-  function peg$f424() {    return 'ALL';  }
-  function peg$f425() {    return 'DISTINCT';  }
-  function peg$f426() {    return 'EXCEPT';  }
-  function peg$f427(beforeQuery, query, afterQuery) {
+  function peg$f529(mode) {    return mode === 'DISTINCT' ? 'UNION DISTINCT' : 'UNION';  }
+  function peg$f530() {    return 'EXCEPT';  }
+  function peg$f531() {    return 'INTERSECT';  }
+  function peg$f532() {    return 'ALL';  }
+  function peg$f533() {    return 'DISTINCT';  }
+  function peg$f534() {    return 'EXCEPT';  }
+  function peg$f535(beforeQuery, query, afterQuery) {
     query = addSurroundingWs(query, beforeQuery, afterQuery);
     // Mark bare parenthesized selects/intersects so they can be wrapped in
     // SelectWithUnionQuery when they appear inside INTERSECT/EXCEPT/UNION DISTINCT.
@@ -2502,7 +2854,7 @@ function peg$parse(input, options) {
     }
     return query;
   }
-  function peg$f428(withClause, from, selectComments, distinct, select, selectTrailing, prewhere, where, groupBy, having, orderBy, limitBy, limit, offset, settings) {
+  function peg$f536(withClause, from, selectComments, distinct, select, selectTrailing, prewhere, where, groupBy, having, orderBy, limitBy, limit, offset, settings) {
     const result = loc({ kind: 'select' });
     if (withClause !== null) {
       result.with = withClause[0].items;
@@ -2522,7 +2874,7 @@ function peg$parse(input, options) {
     if (settings !== null) result.settings = settings[1];
     return result;
   }
-  function peg$f429(withClause, selectComments, distinct, top, select, selectTrailing, withModifier1, from, prewhere, where, withModifier2, groupBy, having, window1, qualify1, orderBy, limitBy, limit, offset, fetch, window2, qualify2, settings) {
+  function peg$f537(withClause, selectComments, distinct, top, select, selectTrailing, withModifier1, from, prewhere, where, withModifier2, groupBy, having, window1, qualify1, orderBy, limitBy, limit, offset, fetch, window2, qualify2, settings) {
     const result = loc({ kind: 'select' });
     let withTrailingComments = [];
     if (withClause !== null) {
@@ -2638,53 +2990,53 @@ function peg$parse(input, options) {
     }
     return result;
   }
-  function peg$f430(cols) {
+  function peg$f538(cols) {
     return { kind: 'distinctOn', on: cols };
   }
-  function peg$f431() {    return 'DISTINCT';  }
-  function peg$f432() {    return 'ALL';  }
-  function peg$f433(wc, head, second, tail) {
+  function peg$f539() {    return 'DISTINCT';  }
+  function peg$f540() {    return 'ALL';  }
+  function peg$f541(wc, head, second, tail) {
     const elements = [head, second, ...tail.map(t => t[3])];
     return { items: [{ kind: 'cteTuple', elements }], keywordComments: wc };
   }
-  function peg$f434(wc, items) {    return { items: items, keywordComments: wc, recursive: true };  }
-  function peg$f435(wc, items) {    return { items: items, keywordComments: wc };  }
-  function peg$f436(expr, afterExpr, name) {
+  function peg$f542(wc, items) {    return { items: items, keywordComments: wc, recursive: true };  }
+  function peg$f543(wc, items) {    return { items: items, keywordComments: wc };  }
+  function peg$f544(expr, afterExpr, name) {
     return loc({ kind: 'alias', expr: addTrailing(expr, flattenWs(afterExpr)), alias: name });
   }
-  function peg$f437(head, tail, lastWs) {
+  function peg$f545(head, tail, lastWs) {
     const items = buildCommaList(head, tail);
     if (lastWs.length > 0) {
       items[items.length - 1] = addTrailing(items[items.length - 1], lastWs);
     }
     return items;
   }
-  function peg$f438(name, head, tail, beforeQuery, query, afterQuery) {
+  function peg$f546(name, head, tail, beforeQuery, query, afterQuery) {
     const result = { kind: 'cteSubquery', name, query: addSurroundingWs(query, beforeQuery, afterQuery) };
     result.columnAliases = [head, ...tail.map(t => t[3])];
     return result;
   }
-  function peg$f439(name, beforeQuery, query, afterQuery) {
+  function peg$f547(name, beforeQuery, query, afterQuery) {
     return { kind: 'cteSubquery', name, query: addSurroundingWs(query, beforeQuery, afterQuery) };
   }
-  function peg$f440(head, tail, body, afterExpr, name) {
+  function peg$f548(head, tail, body, afterExpr, name) {
     const expr = loc({ kind: 'lambdaExpr', params: [head, ...tail.map(t => t[3])], body });
     return { kind: 'cteExpr', name, expr: addTrailing(expr, flattenWs(afterExpr)) };
   }
-  function peg$f441(param, body, afterExpr, name) {
+  function peg$f549(param, body, afterExpr, name) {
     const expr = loc({ kind: 'lambdaExpr', params: [param], body });
     return { kind: 'cteExpr', name, expr: addTrailing(expr, flattenWs(afterExpr)) };
   }
-  function peg$f442(expr, afterExpr, name) {
+  function peg$f550(expr, afterExpr, name) {
     return { kind: 'cteExpr', name, expr: addTrailing(expr, flattenWs(afterExpr)) };
   }
-  function peg$f443(expr) {
+  function peg$f551(expr) {
     return { kind: 'cteExpr', expr };
   }
-  function peg$f444(head, tail) {
+  function peg$f552(head, tail) {
     return buildCommaList(head, tail, 4);
   }
-  function peg$f445(expr, alias) {
+  function peg$f553(expr, alias) {
     if (alias !== null) {
       // Unwrap auto-alias from @@varname when an explicit alias is provided
       const inner = (expr.kind === 'alias' && typeof expr.alias === 'string' && expr.alias.charAt(0) === '@') ? expr.expr : expr;
@@ -2692,13 +3044,13 @@ function peg$parse(input, options) {
     }
     return expr;
   }
-  function peg$f446(alias) {    return alias;  }
-  function peg$f447(alias) {    return alias;  }
-  function peg$f448(comments, expr) {    return addWsLeading(expr, comments);  }
-  function peg$f449(head, tail) {
+  function peg$f554(alias) {    return alias;  }
+  function peg$f555(alias) {    return alias;  }
+  function peg$f556(comments, expr) {    return addWsLeading(expr, comments);  }
+  function peg$f557(head, tail) {
     return tail.reduce((acc, t) => ({ left: acc, ...t[1] }), head);
   }
-  function peg$f450(beforeQuery, query, afterQuery, alias, final, sample) {
+  function peg$f558(beforeQuery, query, afterQuery, alias, final, sample) {
     const result = loc({ kind: 'subqueryFrom', query: addSurroundingWs(query, beforeQuery, afterQuery) });
     if (final !== null) result.final = true;
     if (sample !== null) result.sample = sample[1];
@@ -2712,98 +3064,98 @@ function peg$parse(input, options) {
     }
     return result;
   }
-  function peg$f451(table, alias, final, sample) {
+  function peg$f559(table, alias, final, sample) {
     let result = final !== null ? { ...table, final: true } : table;
     if (sample !== null) result = { ...result, sample: sample[1] };
     if (alias !== null) result = { ...result, alias: typeof alias === 'object' ? alias.alias : alias };
     return result;
   }
-  function peg$f452(table, alias, final, sample) {
+  function peg$f560(table, alias, final, sample) {
     let result = final !== null ? { ...table, final: true } : table;
     if (sample !== null) result = { ...result, sample: sample[1] };
     if (alias !== null) result = { ...result, alias: typeof alias === 'object' ? alias.alias : alias };
     return result;
   }
-  function peg$f453(ratio, offset) {
+  function peg$f561(ratio, offset) {
     const result = { ratio };
     if (offset !== null) result.offset = offset[4];
     return result;
   }
-  function peg$f454(num, den) {    return { num, den };  }
-  function peg$f455(num) {    return { num };  }
-  function peg$f456(digits, frac, exp) {
+  function peg$f562(num, den) {    return { num, den };  }
+  function peg$f563(num) {    return { num };  }
+  function peg$f564(digits, frac, exp) {
     return digits.replace(/_/g, '') + '.' + (frac !== null ? frac.replace(/_/g, '') : '') + (exp !== null ? exp : '');
   }
-  function peg$f457(digits, exp) {
+  function peg$f565(digits, exp) {
     return '.' + digits.replace(/_/g, '') + (exp !== null ? exp : '');
   }
-  function peg$f458(digits, exp) {
+  function peg$f566(digits, exp) {
     return digits.replace(/_/g, '') + exp;
   }
-  function peg$f459(digits) {    return digits.replace(/_/g, '');  }
-  function peg$f460(e, sign, digits) {    return e + (sign !== null ? sign : '') + digits;  }
-  function peg$f461(alias, head, tail) {    return [head, ...tail.map((t) => t[3])];  }
-  function peg$f462(alias, cols) {
+  function peg$f567(digits) {    return digits.replace(/_/g, '');  }
+  function peg$f568(e, sign, digits) {    return e + (sign !== null ? sign : '') + digits;  }
+  function peg$f569(alias, head, tail) {    return [head, ...tail.map((t) => t[3])];  }
+  function peg$f570(alias, cols) {
     return cols !== null ? { alias, columnAliases: cols } : alias;
   }
-  function peg$f463(head, tail) {
+  function peg$f571(head, tail) {
     return { columnAliases: [head, ...tail.map((t) => t[3])] };
   }
-  function peg$f464(alias) {    return alias;  }
-  function peg$f465(name, args, settings) {
+  function peg$f572(alias) {    return alias;  }
+  function peg$f573(name, args, settings) {
     const result = loc({ kind: 'tableFunctionRef', name, args: args !== null ? args : [] });
     if (settings !== null) result.settings = settings[4];
     return result;
   }
-  function peg$f466(head, tail) {
+  function peg$f574(head, tail) {
     return buildCommaList(head, tail);
   }
-  function peg$f467(join_type, exprs) {
+  function peg$f575(join_type, exprs) {
     return loc({ kind: 'arrayJoinExpr', joinType: join_type, expressions: exprs ? exprs[1] : [] });
   }
-  function peg$f468(join_type, right, constraint) {
+  function peg$f576(join_type, right, constraint) {
     return loc({ kind: 'joinExpr', joinType: join_type, right, constraint });
   }
-  function peg$f469(join_type, right) {
+  function peg$f577(join_type, right) {
     return loc({ kind: 'joinExpr', joinType: join_type, right });
   }
-  function peg$f470(right) {
+  function peg$f578(right) {
     return loc({ kind: 'joinExpr', joinType: 'CROSS', right });
   }
-  function peg$f471() {    return "PASTE";  }
-  function peg$f472() {    return "CROSS";  }
-  function peg$f473() {    return "FULL";  }
-  function peg$f474() {    return "LEFT";  }
-  function peg$f475() {    return "RIGHT";  }
-  function peg$f476() {    return "INNER";  }
-  function peg$f477(dir) {    return dir !== null ? dir : "INNER";  }
-  function peg$f478() {    return "LEFT ARRAY";  }
-  function peg$f479() {    return "ARRAY";  }
-  function peg$f480(comments, expr) {    return { kind: 'on', expr: addWsLeading(expr, comments) };  }
-  function peg$f481(cols) {    return { kind: 'using', columns: cols !== null ? cols : [] };  }
-  function peg$f482() {    return { kind: 'using', columns: ['*'] };  }
-  function peg$f483(cols) {    return { kind: 'using', columns: cols };  }
-  function peg$f484(head, tail) {
+  function peg$f579() {    return "PASTE";  }
+  function peg$f580() {    return "CROSS";  }
+  function peg$f581() {    return "FULL";  }
+  function peg$f582() {    return "LEFT";  }
+  function peg$f583() {    return "RIGHT";  }
+  function peg$f584() {    return "INNER";  }
+  function peg$f585(dir) {    return dir !== null ? dir : "INNER";  }
+  function peg$f586() {    return "LEFT ARRAY";  }
+  function peg$f587() {    return "ARRAY";  }
+  function peg$f588(comments, expr) {    return { kind: 'on', expr: addWsLeading(expr, comments) };  }
+  function peg$f589(cols) {    return { kind: 'using', columns: cols !== null ? cols : [] };  }
+  function peg$f590() {    return { kind: 'using', columns: ['*'] };  }
+  function peg$f591(cols) {    return { kind: 'using', columns: cols };  }
+  function peg$f592(head, tail) {
     return [head, ...tail.map((t) => t[3])];
   }
-  function peg$f485(name, alias) {    return { name, alias };  }
-  function peg$f486(name) {    return name;  }
-  function peg$f487(head, tail) {
+  function peg$f593(name, alias) {    return { name, alias };  }
+  function peg$f594(name) {    return name;  }
+  function peg$f595(head, tail) {
     return [head, ...tail.map((t) => t[3])];
   }
-  function peg$f488(comments, expr) {    return addWsLeading(expr, comments);  }
-  function peg$f489(comments, expr) {    return addWsLeading(expr, comments);  }
-  function peg$f490(modifiers) {
+  function peg$f596(comments, expr) {    return addWsLeading(expr, comments);  }
+  function peg$f597(comments, expr) {    return addWsLeading(expr, comments);  }
+  function peg$f598(modifiers) {
     const withTotals = modifiers.some((m) => m === 'TOTALS');
     const withCube = modifiers.some((m) => m === 'CUBE');
     const withRollup = modifiers.some((m) => m === 'ROLLUP');
     return { all: true, withTotals, withCube, withRollup };
   }
-  function peg$f491(sets, modifiers) {
+  function peg$f599(sets, modifiers) {
     const withTotals = modifiers.some((m) => m === 'TOTALS');
     return { groupingSets: sets, withTotals };
   }
-  function peg$f492(keywordComments, exprList, modifiers) {
+  function peg$f600(keywordComments, exprList, modifiers) {
     const withTotals = modifiers.some((m) => m === 'TOTALS');
     const withCube = modifiers.some((m) => m === 'CUBE');
     const withRollup = modifiers.some((m) => m === 'ROLLUP');
@@ -2815,75 +3167,75 @@ function peg$parse(input, options) {
     }
     return { items, withTotals, withCube, withRollup };
   }
-  function peg$f493(head, tail) {
+  function peg$f601(head, tail) {
     return [head, ...tail.map((t) => t[3])];
   }
-  function peg$f494(items) {    return items;  }
-  function peg$f495() {    return [];  }
-  function peg$f496(expr) {    return [expr];  }
-  function peg$f497() {    return 'TOTALS';  }
-  function peg$f498() {    return 'ROLLUP';  }
-  function peg$f499() {    return 'CUBE';  }
-  function peg$f500() {    return 'TOTALS';  }
-  function peg$f501() {    return 'ROLLUP';  }
-  function peg$f502() {    return 'CUBE';  }
-  function peg$f503(comments, expr) {    return addWsLeading(expr, comments);  }
-  function peg$f504(comments, expr) {    return addWsLeading(expr, comments);  }
-  function peg$f505(items) {    return items;  }
-  function peg$f506(count) {    return { count: count, by: [] };  }
-  function peg$f507(offset, count) {
+  function peg$f602(items) {    return items;  }
+  function peg$f603() {    return [];  }
+  function peg$f604(expr) {    return [expr];  }
+  function peg$f605() {    return 'TOTALS';  }
+  function peg$f606() {    return 'ROLLUP';  }
+  function peg$f607() {    return 'CUBE';  }
+  function peg$f608() {    return 'TOTALS';  }
+  function peg$f609() {    return 'ROLLUP';  }
+  function peg$f610() {    return 'CUBE';  }
+  function peg$f611(comments, expr) {    return addWsLeading(expr, comments);  }
+  function peg$f612(comments, expr) {    return addWsLeading(expr, comments);  }
+  function peg$f613(items) {    return items;  }
+  function peg$f614(count) {    return { count: count, by: [] };  }
+  function peg$f615(offset, count) {
     return { count: count, by: [], limitByOffset: offset };
   }
-  function peg$f508(count, offset) {
+  function peg$f616(count, offset) {
     return { count: count, by: [], limitByOffset: offset };
   }
-  function peg$f509(offset, count, by) {
+  function peg$f617(offset, count, by) {
     return { count: count, by: by, limitByOffset: offset };
   }
-  function peg$f510(count, offset, by) {
+  function peg$f618(count, offset, by) {
     return { count: count, by: by, limitByOffset: offset };
   }
-  function peg$f511(count, by) {
+  function peg$f619(count, by) {
     return { count: count, by: by };
   }
-  function peg$f512(count, offset) {    return { count: count, offset: offset, comma: true, withTies: true };  }
-  function peg$f513(count, offset) {    return { count: count, offset: offset, comma: true };  }
-  function peg$f514(count) {    return { count: count, comma: false, withTies: true };  }
-  function peg$f515(count) {    return { count: count, comma: false };  }
-  function peg$f516(count) {    return count;  }
-  function peg$f517(count, ties) {
+  function peg$f620(count, offset) {    return { count: count, offset: offset, comma: true, withTies: true };  }
+  function peg$f621(count, offset) {    return { count: count, offset: offset, comma: true };  }
+  function peg$f622(count) {    return { count: count, comma: false, withTies: true };  }
+  function peg$f623(count) {    return { count: count, comma: false };  }
+  function peg$f624(count) {    return count;  }
+  function peg$f625(count, ties) {
     return { count: count, withTies: typeof ties === 'string' ? false : true };
   }
-  function peg$f518(items) {    return items;  }
-  function peg$f519(items) {    return items;  }
-  function peg$f520(head, tail) {
+  function peg$f626(items) {    return items;  }
+  function peg$f627(items) {    return items;  }
+  function peg$f628(head, tail) {
     return [head, ...tail.map((t) => t[3])];
   }
-  function peg$f521(name, baseWindow, spec) {
+  function peg$f629(name, baseWindow, spec) {
     spec.baseWindow = baseWindow;
     return { name, spec };
   }
-  function peg$f522(name, spec) {
+  function peg$f630(name, spec) {
     return { name, spec };
   }
-  function peg$f523(head, tail) {
+  function peg$f631(head, tail) {
     return [head, ...tail.map((t) => t[3])];
   }
-  function peg$f524(head, tail) {    return head + tail.join('');  }
-  function peg$f525(chars) {    return chars.join('');  }
-  function peg$f526(chars) {    return chars.join('');  }
-  function peg$f527(name, value, forResource) {
+  function peg$f632(head, tail) {    return head + tail.join('');  }
+  function peg$f633(chars) {    return chars.join('');  }
+  function peg$f634(chars) {    return chars.join('');  }
+  function peg$f635(name, value, forResource) {
     const result = { name, value };
     if (forResource !== null) result.forResource = forResource[3];
     return result;
   }
-  function peg$f528(name) {
+  function peg$f636(name) {
     return { name, value: loc({ kind: 'literal', type: 'UInt64', value: '1' }) };
   }
-  function peg$f529(head, tail) {
+  function peg$f637(head, tail) {
     return [head, ...tail.map((t) => t[3])];
   }
-  function peg$f530(expr, alias, dir, nulls, collate, fill) {
+  function peg$f638(expr, alias, dir, nulls, collate, fill) {
     const resolvedExpr = alias !== null ? loc({ kind: 'alias', expr, alias: alias[3] }) : expr;
     const result = loc({ kind: 'orderByItem', expr: resolvedExpr, direction: dir !== null ? dir[1].toUpperCase() : 'ASC' });
     if (collate !== null) result.collate = collate[4].value;
@@ -2899,7 +3251,7 @@ function peg$parse(input, options) {
     }
     return result;
   }
-  function peg$f531(from, to, step, staleness, interp) {
+  function peg$f639(from, to, step, staleness, interp) {
     const result = {};
     if (from !== null && from[4] !== null) result.fillFrom = from[4];
     if (to !== null && to[4] !== null) result.fillTo = to[4];
@@ -2908,69 +3260,69 @@ function peg$parse(input, options) {
     if (interp !== null) result.interpolate = interp[6];
     return result;
   }
-  function peg$f532(head, tail) {    return [head, ...tail.map((t) => t[3])];  }
-  function peg$f533() {    return [];  }
-  function peg$f534(col, expr) {    return { col: col, expr: expr };  }
-  function peg$f535(col) {    return { col: col };  }
-  function peg$f536(head, tail) {    return buildCommaList(head, tail);  }
-  function peg$f537(expr, asWs, alias) {
+  function peg$f640(head, tail) {    return [head, ...tail.map((t) => t[3])];  }
+  function peg$f641() {    return [];  }
+  function peg$f642(col, expr) {    return { col: col, expr: expr };  }
+  function peg$f643(col) {    return { col: col };  }
+  function peg$f644(head, tail) {    return buildCommaList(head, tail);  }
+  function peg$f645(expr, asWs, alias) {
     // Unwrap auto-alias (e.g. @@varname) if an explicit AS alias is provided
     const inner = (expr.kind === 'alias' && typeof expr.alias === 'string' && expr.alias.charAt(0) === '@') ? expr.expr : expr;
     return loc({ kind: 'alias', expr: addTrailing(inner, flattenWs(asWs)), alias });
   }
-  function peg$f538(expr, asWs, alias) {
+  function peg$f646(expr, asWs, alias) {
     const inner = (expr.kind === 'alias' && typeof expr.alias === 'string' && expr.alias.charAt(0) === '@') ? expr.expr : expr;
     return loc({ kind: 'alias', expr: addTrailing(inner, flattenWs(asWs)), alias });
   }
-  function peg$f539(expr, aliasWs, alias) {
+  function peg$f647(expr, aliasWs, alias) {
     return loc({ kind: 'alias', expr: addTrailing(expr, flattenWs(aliasWs)), alias });
   }
-  function peg$f540(cond, ws1, ws2, then, ws3, ws4, else_) {
+  function peg$f648(cond, ws1, ws2, then, ws3, ws4, else_) {
     return loc({ kind: 'functionCall', name: 'if', args: [
       cond,
       addLeading(then, [...flattenWs(ws1), ...flattenWs(ws2)]),
       addLeading(else_, [...flattenWs(ws3), ...flattenWs(ws4)])
     ] });
   }
-  function peg$f541(head, tail) {
+  function peg$f649(head, tail) {
     const operands = [head, ...tail.map((t) => addLeading(t[3], [...flattenWs(t[0]), ...flattenWs(t[2])]))];
     return loc({ kind: 'naryExpr', op: 'OR', operands });
   }
-  function peg$f542(head, tail) {
+  function peg$f650(head, tail) {
     const operands = [head, ...tail.map((t) => addLeading(t[3], [...flattenWs(t[0]), ...flattenWs(t[2])]))];
     return loc({ kind: 'naryExpr', op: 'AND', operands });
   }
-  function peg$f543(comments, expr) {
+  function peg$f651(comments, expr) {
     return loc({ kind: 'unaryExpr', op: 'NOT', expr: addWsLeading(expr, comments) });
   }
-  function peg$f544(base, rest) {
+  function peg$f652(base, rest) {
     return rest.reduce((acc, t) => (loc({
       kind: 'binaryExpr', op: t[1], left: acc,
       right: addLeading(t[3], [...flattenWs(t[0]), ...flattenWs(t[2])])
     })), base);
   }
-  function peg$f545(left, suffixes) {
+  function peg$f653(left, suffixes) {
     return suffixes.reduce((acc, s) => s(acc), left);
   }
-  function peg$f546(global, negated, target) {
+  function peg$f654(global, negated, target) {
     return (left) => {
       const result = loc({ kind: 'inExpr', negated: negated !== null, expr: left, ...target });
       if (global !== null) result.global = true;
       return result;
     };
   }
-  function peg$f547(negated, right) {
+  function peg$f655(negated, right) {
     const name = negated !== null ? 'notILike' : 'ilike';
     return (left) => (loc({ kind: 'functionCall', name, args: [left, right] }));
   }
-  function peg$f548(negated, right) {
+  function peg$f656(negated, right) {
     const name = negated !== null ? 'notLike' : 'like';
     return (left) => (loc({ kind: 'functionCall', name, args: [left, right] }));
   }
-  function peg$f549(right) {
+  function peg$f657(right) {
     return (left) => (loc({ kind: 'functionCall', name: 'match', args: [left, right] }));
   }
-  function peg$f550(low, high) {
+  function peg$f658(low, high) {
     return (left) => (loc({
       kind: 'functionCall', name: 'or', args: [
         loc({ kind: 'functionCall', name: 'less', args: [left, low] }),
@@ -2978,7 +3330,7 @@ function peg$parse(input, options) {
       ]
     }));
   }
-  function peg$f551(low, high) {
+  function peg$f659(low, high) {
     return (left) => (loc({
       kind: 'functionCall', name: 'and', args: [
         loc({ kind: 'functionCall', name: 'greaterOrEquals', args: [left, low] }),
@@ -2986,26 +3338,26 @@ function peg$parse(input, options) {
       ]
     }));
   }
-  function peg$f552(type) {
+  function peg$f660(type) {
     return (left) => (loc({ kind: 'castExpr', expr: left, type: type, operator: true }));
   }
-  function peg$f553(arith) {
+  function peg$f661(arith) {
     return (left) => {
       const base = loc({ kind: 'functionCall', name: 'isNotNull', args: [left] });
       return arith.reduce((acc, t) => (loc({ kind: 'binaryExpr', op: t[1], left: acc, right: t[3] })), base);
     };
   }
-  function peg$f554(arith) {
+  function peg$f662(arith) {
     return (left) => {
       const base = loc({ kind: 'functionCall', name: 'isNull', args: [left] });
       return arith.reduce((acc, t) => (loc({ kind: 'binaryExpr', op: t[1], left: acc, right: t[3] })), base);
     };
   }
-  function peg$f555() {    return '<=>';  }
-  function peg$f556() {    return 'IS DISTINCT FROM';  }
-  function peg$f557(op) {    return op;  }
-  function peg$f558(arr) {    return { values: [arr] };  }
-  function peg$f559(beforeValues, values, afterValues) {
+  function peg$f663() {    return '<=>';  }
+  function peg$f664() {    return 'IS DISTINCT FROM';  }
+  function peg$f665(op) {    return op;  }
+  function peg$f666(arr) {    return { values: [arr] };  }
+  function peg$f667(beforeValues, values, afterValues) {
     // Attach comments to first/last value if they are expression nodes
     if (Array.isArray(values)) {
       const bv = flattenWs(beforeValues);
@@ -3020,36 +3372,36 @@ function peg$parse(input, options) {
     }
     return { values };
   }
-  function peg$f560(single) {    return { values: [single] };  }
-  function peg$f561(expr) {    return loc({ kind: 'unaryExpr', op: 'NOT', expr: expr });  }
-  function peg$f562(left, suffixes) {
+  function peg$f668(single) {    return { values: [single] };  }
+  function peg$f669(expr) {    return loc({ kind: 'unaryExpr', op: 'NOT', expr: expr });  }
+  function peg$f670(left, suffixes) {
     return suffixes.reduce((acc, s) => s(acc), left);
   }
-  function peg$f563(query) {    return loc({ kind: 'subqueryExpr', query: query });  }
-  function peg$f564(head, tail) {
+  function peg$f671(query) {    return loc({ kind: 'subqueryExpr', query: query });  }
+  function peg$f672(head, tail) {
     return tail.reduce((acc, t) => (loc({
       kind: 'binaryExpr', op: t[1], left: acc,
       right: addLeading(t[3], [...flattenWs(t[0]), ...flattenWs(t[2])])
     })), head);
   }
-  function peg$f565(expr) {    return loc({ kind: 'unaryExpr', op: 'NOT', expr: expr });  }
-  function peg$f566() {    return "-";  }
-  function peg$f567() {    return "-";  }
-  function peg$f568(head, tail) {
+  function peg$f673(expr) {    return loc({ kind: 'unaryExpr', op: 'NOT', expr: expr });  }
+  function peg$f674() {    return "-";  }
+  function peg$f675() {    return "-";  }
+  function peg$f676(head, tail) {
     if (tail.length === 0) return head;
     const parts = [head, ...tail.map((t) => addLeading(t[3], [...flattenWs(t[0]), ...flattenWs(t[2])]))];
     return loc({ kind: 'functionCall', name: 'concat', args: parts });
   }
-  function peg$f569(head, tail) {
+  function peg$f677(head, tail) {
     return tail.reduce((acc, t) => (loc({
       kind: 'binaryExpr', op: t[1], left: acc,
       right: addLeading(t[3], [...flattenWs(t[0]), ...flattenWs(t[2])])
     })), head);
   }
-  function peg$f570() {    return 'DIV';  }
-  function peg$f571() {    return 'MOD';  }
-  function peg$f572(expr) {    return expr;  }
-  function peg$f573(expr) {
+  function peg$f678() {    return 'DIV';  }
+  function peg$f679() {    return 'MOD';  }
+  function peg$f680(expr) {    return expr;  }
+  function peg$f681(expr) {
     // Don't fold across explicit parentheses: -(1) must produce negate(1), not Int64_-1.
     // (-1) without an outer minus stays as a UInt64 literal — only `-` immediately before a
     // bare literal folds. A parenthesized inner expression always wraps in negate().
@@ -3112,7 +3464,7 @@ function peg$parse(input, options) {
     // For all other cases (non-literal, already-negative literal, etc.), wrap in negate()
     return loc({ kind: 'functionCall', name: 'negate', args: [expr] });
   }
-  function peg$f574(base, suffixes, over) {
+  function peg$f682(base, suffixes, over) {
     const result = suffixes.reduce((acc, s) => {
       if (s.kind === 'subscript') {
         return loc({ kind: 'functionCall', name: 'arrayElement', args: [acc, s.index] });
@@ -3158,112 +3510,112 @@ function peg$parse(input, options) {
     }
     return result;
   }
-  function peg$f575(spec) {    return spec;  }
-  function peg$f576(spec) {    return spec;  }
-  function peg$f577() {    return null;  }
-  function peg$f578(items) {    return items;  }
-  function peg$f579(partitionBy, items) {    return items;  }
-  function peg$f580(partitionBy, orderBy, frame) {
+  function peg$f683(spec) {    return spec;  }
+  function peg$f684(spec) {    return spec;  }
+  function peg$f685() {    return null;  }
+  function peg$f686(items) {    return items;  }
+  function peg$f687(partitionBy, items) {    return items;  }
+  function peg$f688(partitionBy, orderBy, frame) {
     const spec = {};
     if (partitionBy !== null) spec.partitionBy = partitionBy;
     if (orderBy !== null) spec.orderBy = orderBy;
     if (frame !== null) spec.frame = frame;
     return spec;
   }
-  function peg$f581(type, start, end) {
+  function peg$f689(type, start, end) {
     return { frameType: type, start: start, end: end };
   }
-  function peg$f582(type, bound) {
+  function peg$f690(type, bound) {
     return { frameType: type, start: bound };
   }
-  function peg$f583() {    return text().toLowerCase();  }
-  function peg$f584() {    return { kind: 'unbounded' };  }
-  function peg$f585() {    return { kind: 'unbounded' };  }
-  function peg$f586() {    return { kind: 'currentRow' };  }
-  function peg$f587(expr) {    return { kind: 'preceding', expr: expr };  }
-  function peg$f588(expr) {    return { kind: 'following', expr: expr };  }
-  function peg$f589(type) {    return { kind: 'cast', type: type };  }
-  function peg$f590(type, name) {    return name;  }
-  function peg$f591(type, path) {
+  function peg$f691() {    return text().toLowerCase();  }
+  function peg$f692() {    return { kind: 'unbounded' };  }
+  function peg$f693() {    return { kind: 'unbounded' };  }
+  function peg$f694() {    return { kind: 'currentRow' };  }
+  function peg$f695(expr) {    return { kind: 'preceding', expr: expr };  }
+  function peg$f696(expr) {    return { kind: 'following', expr: expr };  }
+  function peg$f697(type) {    return { kind: 'cast', type: type };  }
+  function peg$f698(type, name) {    return name;  }
+  function peg$f699(type, path) {
     return { kind: 'json_subcolumn', type: type, path: path };
   }
-  function peg$f592(index) {    return { kind: 'subscript', index: index };  }
-  function peg$f593(index) {    return { kind: 'tuple_element', index: index };  }
-  function peg$f594(index) {    return { kind: 'tuple_element', index: '-' + index };  }
-  function peg$f595(name) {    return { kind: 'field_access', name: name };  }
-  function peg$f596(transformers) {
+  function peg$f700(index) {    return { kind: 'subscript', index: index };  }
+  function peg$f701(index) {    return { kind: 'tuple_element', index: index };  }
+  function peg$f702(index) {    return { kind: 'tuple_element', index: '-' + index };  }
+  function peg$f703(name) {    return { kind: 'field_access', name: name };  }
+  function peg$f704(transformers) {
     return { kind: 'asterisk_access', transformers: transformers.map((t) => t[1]) };
   }
-  function peg$f597(chars) {    return chars.join('');  }
-  function peg$f598() {    return text().toUpperCase().replace(/\s+/g, ' ').trim();  }
-  function peg$f599(mw, args) {
+  function peg$f705(chars) {    return chars.join('');  }
+  function peg$f706() {    return text().toUpperCase().replace(/\s+/g, ' ').trim();  }
+  function peg$f707(mw, args) {
     const result = { name: mw };
     if (args !== null) result.args = args[3] !== null ? args[3] : [];
     return result;
   }
-  function peg$f600(name) {    return { name };  }
-  function peg$f601(name) {    return { name };  }
-  function peg$f602(name, values) {
+  function peg$f708(name) {    return { name };  }
+  function peg$f709(name) {    return { name };  }
+  function peg$f710(name, values) {
     return { name: name.trim(), args: [{ kind: 'enumValues', values }] };
   }
-  function peg$f603(name) {
+  function peg$f711(name) {
     return { name: name.trim() };
   }
-  function peg$f604(name, args, suffix) {
+  function peg$f712(name, args, suffix) {
     let typeName = name;
     if (suffix !== null) typeName = (name + ' ' + suffix[1]).toUpperCase();
     const result = { name: typeName };
     if (args !== null) result.args = args[3] || [];
     return result;
   }
-  function peg$f605(head, tail) {
+  function peg$f713(head, tail) {
     return [head, ...tail.map(t => t[3])];
   }
-  function peg$f606(name, value) {    return { name: name.value, value: value.replace(/\s/g, '') };  }
-  function peg$f607() {    return { name: null, value: null };  }
-  function peg$f608(name) {    return { name: name.value };  }
-  function peg$f609(head, tail, trailing_comma) {
+  function peg$f714(name, value) {    return { name: name.value, value: value.replace(/\s/g, '') };  }
+  function peg$f715() {    return { name: null, value: null };  }
+  function peg$f716(name) {    return { name: name.value };  }
+  function peg$f717(head, tail, trailing_comma) {
     return [head, ...tail.map(t => t[3])];
   }
-  function peg$f610(str) {
+  function peg$f718(str) {
     return { kind: 'literal', value: 'SKIP REGEXP ' + str };
   }
-  function peg$f611(path) {
+  function peg$f719(path) {
     return { kind: 'literal', value: 'SKIP ' + path };
   }
-  function peg$f612(name, type) {
+  function peg$f720(name, type) {
     return { kind: 'namedField', name: name.replace(/[`"]/g, ''), type };
   }
-  function peg$f613(str) {    return { kind: 'literal', value: str };  }
-  function peg$f614(val) {    return { kind: 'literal', value: val };  }
-  function peg$f615(name, val) {
+  function peg$f721(str) {    return { kind: 'literal', value: str };  }
+  function peg$f722(val) {    return { kind: 'literal', value: val };  }
+  function peg$f723(name, val) {
     return { kind: 'setting', name: name, value: val };
   }
-  function peg$f616(type) {    return { kind: 'type', type };  }
-  function peg$f617(raw) {    return { kind: 'literal', value: raw };  }
-  function peg$f618(parts) {    return text();  }
-  function peg$f619(mw) {    return mw;  }
-  function peg$f620(name) {    return name;  }
-  function peg$f621(name) {    return name;  }
-  function peg$f622(name, args) {
+  function peg$f724(type) {    return { kind: 'type', type };  }
+  function peg$f725(raw) {    return { kind: 'literal', value: raw };  }
+  function peg$f726(parts) {    return text();  }
+  function peg$f727(mw) {    return mw;  }
+  function peg$f728(name) {    return name;  }
+  function peg$f729(name) {    return name;  }
+  function peg$f730(name, args) {
     return name + (args !== null ? args : '');
   }
-  function peg$f623(parts) {
+  function peg$f731(parts) {
     return "(" + parts.join("") + ")";
   }
-  function peg$f624(nested) {    return nested;  }
-  function peg$f625(str) {    return str;  }
-  function peg$f626(chars) {    return chars;  }
-  function peg$f627(tuple) {    return loc({ kind: 'functionCall', name: 'not', args: [tuple] });  }
-  function peg$f628(expr) {    return loc({ kind: 'unaryExpr', op: 'NOT', expr: expr });  }
-  function peg$f629(first, part) {    return part;  }
-  function peg$f630(first, rest) {
+  function peg$f732(nested) {    return nested;  }
+  function peg$f733(str) {    return str;  }
+  function peg$f734(chars) {    return chars;  }
+  function peg$f735(tuple) {    return loc({ kind: 'functionCall', name: 'not', args: [tuple] });  }
+  function peg$f736(expr) {    return loc({ kind: 'unaryExpr', op: 'NOT', expr: expr });  }
+  function peg$f737(first, part) {    return part;  }
+  function peg$f738(first, rest) {
     return loc({ kind: 'columnRef', parts: [first, ...rest] });
   }
-  function peg$f631(name) {    return loc({ kind: 'columnRef', parts: [name] });  }
-  function peg$f632(name) {    return loc({ kind: 'columnRef', parts: [name] });  }
-  function peg$f633() {    return loc({ kind: 'functionCall', name: 'map', args: [] });  }
-  function peg$f634(first, rest) {
+  function peg$f739(name) {    return loc({ kind: 'columnRef', parts: [name] });  }
+  function peg$f740(name) {    return loc({ kind: 'columnRef', parts: [name] });  }
+  function peg$f741() {    return loc({ kind: 'functionCall', name: 'map', args: [] });  }
+  function peg$f742(first, rest) {
     const args = [first[0], first[1]];
     for (const r of rest) {
       args.push(r[3][0]);
@@ -3271,21 +3623,21 @@ function peg$parse(input, options) {
     }
     return loc({ kind: 'functionCall', name: 'map', args });
   }
-  function peg$f635(key, value) {    return [key, value];  }
-  function peg$f636(name) {
+  function peg$f743(key, value) {    return [key, value];  }
+  function peg$f744(name) {
     return loc({ kind: 'alias', alias: '@@' + name, expr: loc({ kind: 'functionCall', name: 'globalVariable', args: [loc({ kind: 'literal', type: 'String', value: name })] }) });
   }
-  function peg$f637(body) {
+  function peg$f745(body) {
     return loc({ kind: 'lambdaExpr', params: [], body });
   }
-  function peg$f638() {    return loc({ kind: 'functionCall', name: 'tuple', args: [] });  }
-  function peg$f639(beforeQuery, query, afterQuery) {
+  function peg$f746() {    return loc({ kind: 'functionCall', name: 'tuple', args: [] });  }
+  function peg$f747(beforeQuery, query, afterQuery) {
     return loc({ kind: 'subqueryExpr', query: addSurroundingWs(query, beforeQuery, afterQuery) });
   }
-  function peg$f640(head, tail, body) {
+  function peg$f748(head, tail, body) {
     return loc({ kind: 'lambdaExpr', params: [head, ...tail.map((t) => t[3])], body });
   }
-  function peg$f641(beforeFirst, first, rest, trailing, afterLast) {
+  function peg$f749(beforeFirst, first, rest, trailing, afterLast) {
     first = addLeading(first, flattenWs(beforeFirst));
     if (rest.length === 0 && trailing === null) {
       // (expr) — parenthesized expression
@@ -3300,16 +3652,16 @@ function peg$parse(input, options) {
       return loc({ kind: 'tupleLiteral', elements: elems, source: text() });
     }
   }
-  function peg$f642(elem) {
+  function peg$f750(elem) {
     return loc({ kind: 'functionCall', name: 'tuple', args: [elem] });
   }
-  function peg$f643(first, rest) {
+  function peg$f751(first, rest) {
     return loc({ kind: 'tupleLiteral', elements: [first, ...rest], source: text() });
   }
-  function peg$f644() {
+  function peg$f752() {
     return loc({ kind: 'arrayLiteral', elements: [], source: text() });
   }
-  function peg$f645(beforeItems, items, afterItems) {
+  function peg$f753(beforeItems, items, afterItems) {
     const bi = flattenWs(beforeItems);
     const ai = flattenWs(afterItems);
     if ((bi.length > 0 || ai.length > 0) && items.length > 0) {
@@ -3319,10 +3671,10 @@ function peg$parse(input, options) {
     }
     return loc({ kind: 'arrayLiteral', elements: items, source: text() });
   }
-  function peg$f646(name, type) {
+  function peg$f754(name, type) {
     return loc({ kind: 'queryParam', name: name, type: type.trim() });
   }
-  function peg$f647(tag) {
+  function peg$f755(tag) {
     const endMarker = `$${tag}$`;
     const pos = input.indexOf(endMarker, peg$currPos);
     if (pos < 0) { error(`Unterminated heredoc $${tag}$`); }
@@ -3331,12 +3683,12 @@ function peg$parse(input, options) {
     // Double backslashes so escapeStringValue in explain.ts outputs them correctly (consistent with StringChar handling of \\)
     return loc({ kind: 'literal', type: 'String', value: content.replace(/\\/g, '\\\\') });
   }
-  function peg$f648() {    return loc({ kind: 'literal', type: 'Bool', value: '1' });  }
-  function peg$f649() {    return loc({ kind: 'literal', type: 'Bool', value: '0' });  }
-  function peg$f650() {
+  function peg$f756() {    return loc({ kind: 'literal', type: 'Bool', value: '1' });  }
+  function peg$f757() {    return loc({ kind: 'literal', type: 'Bool', value: '0' });  }
+  function peg$f758() {
     return loc({ kind: 'literal', type: 'NULL', value: 'NULL' });
   }
-  function peg$f651(digits) {
+  function peg$f759(digits) {
     if (digits.length === 0) return loc({ kind: 'literal', type: 'String', value: '' });
     // Pad to multiple of 8 bits, MSB-first, then interpret as UTF-8 bytes
     const padded = digits.padStart(Math.ceil(digits.length / 8) * 8, '0');
@@ -3346,12 +3698,12 @@ function peg$parse(input, options) {
     }
     return loc({ kind: 'literal', type: 'String', value: Buffer.from(bytes).toString('utf-8') });
   }
-  function peg$f652(digits) {
+  function peg$f760(digits) {
     if (digits.length === 0) return loc({ kind: 'literal', type: 'String', value: '' });
     const padded = digits.length % 2 === 1 ? '0' + digits : digits;
     return loc({ kind: 'literal', type: 'String', value: Buffer.from(padded, 'hex').toString('utf-8') });
   }
-  function peg$f653(int, frac, exp) {
+  function peg$f761(int, frac, exp) {
     const cleanInt = int.replace(/_/g, '');
     const cleanFrac = (frac || '').replace(/_/g, '');
     const intVal = parseInt(cleanInt, 16);
@@ -3359,7 +3711,7 @@ function peg$parse(input, options) {
     const value = exp !== null ? (intVal + fracVal) * Math.pow(2, exp) : (intVal + fracVal);
     return loc({ kind: 'literal', type: 'Float64', value: value.toString(), source: text() });
   }
-  function peg$f654(digits, exp) {
+  function peg$f762(digits, exp) {
     // Remove underscore digit separators
     const clean = digits.replace(/_/g, '');
     // Parse hex with optional exponent (e.g. 0x123p4) as float
@@ -3373,28 +3725,28 @@ function peg$parse(input, options) {
     }
     return loc({ kind: 'literal', type: 'UInt64', value: '0x' + clean });
   }
-  function peg$f655(sign, digits) {    return (sign === '-' ? -1 : 1) * parseInt(digits.replace(/_/g, ''), 10);  }
-  function peg$f656(digits) {
+  function peg$f763(sign, digits) {    return (sign === '-' ? -1 : 1) * parseInt(digits.replace(/_/g, ''), 10);  }
+  function peg$f764(digits) {
     // Remove underscore digit separators
     const clean = digits.replace(/_/g, '');
     return loc({ kind: 'literal', type: 'UInt64', value: '0b' + clean });
   }
-  function peg$f657() {    return loc({ kind: 'literal', type: 'Float64', value: 'inf' });  }
-  function peg$f658() {    return loc({ kind: 'literal', type: 'Float64', value: 'nan' });  }
-  function peg$f659(digits, frac, exp) {
+  function peg$f765() {    return loc({ kind: 'literal', type: 'Float64', value: 'inf' });  }
+  function peg$f766() {    return loc({ kind: 'literal', type: 'Float64', value: 'nan' });  }
+  function peg$f767(digits, frac, exp) {
     return loc({ kind: 'literal', type: 'Float64', value: digits.replace(/_/g, '') + '.' + (frac || '').replace(/_/g, '') + (exp || '') });
   }
-  function peg$f660(digits, exp) {
+  function peg$f768(digits, exp) {
     return loc({ kind: 'literal', type: 'Float64', value: '.' + digits.replace(/_/g, '') + (exp || '') });
   }
-  function peg$f661(digits, exp) {
+  function peg$f769(digits, exp) {
     return loc({ kind: 'literal', type: 'Float64', value: digits.replace(/_/g, '') + exp });
   }
-  function peg$f662(e, sign, digits) {    return e + sign + digits.replace(/_/g, '');  }
-  function peg$f663(param, body) {
+  function peg$f770(e, sign, digits) {    return e + sign + digits.replace(/_/g, '');  }
+  function peg$f771(param, body) {
     return loc({ kind: 'lambdaExpr', params: [param], body: body });
   }
-  function peg$f664(branches, elseClause) {
+  function peg$f772(branches, elseClause) {
     const args = [];
     for (const branch of branches) {
       args.push(branch[0]);
@@ -3403,7 +3755,7 @@ function peg$parse(input, options) {
     args.push(elseClause !== null ? elseClause[4] : loc({ kind: 'literal', type: 'NULL', value: 'NULL' }));
     return loc({ kind: 'functionCall', name: 'multiIf', args });
   }
-  function peg$f665(subject, branches, elseClause) {
+  function peg$f773(subject, branches, elseClause) {
     const args = [subject];
     for (const branch of branches) {
       args.push(branch[0]);
@@ -3412,13 +3764,13 @@ function peg$parse(input, options) {
     args.push(elseClause !== null ? elseClause[4] : loc({ kind: 'literal', type: 'NULL', value: 'NULL' }));
     return loc({ kind: 'functionCall', name: 'caseWithExpression', args });
   }
-  function peg$f666(cond, val) {
+  function peg$f774(cond, val) {
     return [cond, val];
   }
-  function peg$f667(expr, unit) {
+  function peg$f775(expr, unit) {
     return loc({ kind: 'functionCall', name: 'toInterval' + unit, args: [expr] });
   }
-  function peg$f668(str) {
+  function peg$f776(str) {
     const parts = str.value.trim().split(/\s+/);
     const unitMap = {
       NANOSECOND: 'Nanosecond', MICROSECOND: 'Microsecond', MILLISECOND: 'Millisecond',
@@ -3437,27 +3789,27 @@ function peg$parse(input, options) {
     // Multi-part interval: wrap in tuple (ClickHouse expands into addTupleOfIntervals)
     return loc({ kind: 'functionCall', name: 'tuple', args: intervals });
   }
-  function peg$f669(word) {    return INTERVAL_UNITS[word.toLowerCase()] !== undefined;  }
-  function peg$f670(word) {
+  function peg$f777(word) {    return INTERVAL_UNITS[word.toLowerCase()] !== undefined;  }
+  function peg$f778(word) {
     return INTERVAL_UNITS[word.toLowerCase()];
   }
-  function peg$f671() {    return 'plus';  }
-  function peg$f672() {    return 'minus';  }
-  function peg$f673(unit, amount, date) {
+  function peg$f779() {    return 'plus';  }
+  function peg$f780() {    return 'minus';  }
+  function peg$f781(unit, amount, date) {
     return [date, loc({ kind: 'functionCall', name: 'toInterval' + unit, args: [amount] })];
   }
-  function peg$f674(date, interval) {    return [date, interval];  }
-  function peg$f675(interval, date) {    return [interval, date];  }
-  function peg$f676(fn, args) {
+  function peg$f782(date, interval) {    return [date, interval];  }
+  function peg$f783(interval, date) {    return [interval, date];  }
+  function peg$f784(fn, args) {
     return loc({ kind: 'functionCall', name: fn, args: args });
   }
-  function peg$f677(fn, args) {
+  function peg$f785(fn, args) {
     return loc({ kind: 'functionCall', name: fn, args: args });
   }
-  function peg$f678(unit, amount, date) {
+  function peg$f786(unit, amount, date) {
     return loc({ kind: 'functionCall', name: 'minus', args: [date, loc({ kind: 'functionCall', name: 'toInterval' + unit, args: [amount] })] });
   }
-  function peg$f679(unit, rest) {
+  function peg$f787(unit, rest) {
     const unitAliases = {
       'ns': 'nanosecond', 'nanoseconds': 'nanosecond',
       'us': 'microsecond', 'microseconds': 'microsecond',
@@ -3477,15 +3829,15 @@ function peg$parse(input, options) {
     const unitLiteral = loc({ kind: 'literal', type: 'String', value: canonical });
     return loc({ kind: 'functionCall', name: 'dateDiff', args: [unitLiteral, ...rest] });
   }
-  function peg$f680(args) {
+  function peg$f788(args) {
     return loc({ kind: 'functionCall', name: 'dateDiff', args: args });
   }
-  function peg$f681(str, pos, len) {
+  function peg$f789(str, pos, len) {
     const args = [str, pos];
     if (len !== null) args.push(len[4]);
     return loc({ kind: 'functionCall', name: 'substring', args });
   }
-  function peg$f682(unit, expr) {
+  function peg$f790(unit, expr) {
     const funcMap = {
       YEAR: 'toYear', MONTH: 'toMonth', DAY: 'toDayOfMonth',
       HOUR: 'toHour', MINUTE: 'toMinute', SECOND: 'toSecond',
@@ -3499,7 +3851,7 @@ function peg$parse(input, options) {
     const funcName = funcMap[unit.toUpperCase()] || ('to' + unit.charAt(0).toUpperCase() + unit.slice(1).toLowerCase());
     return loc({ kind: 'functionCall', name: funcName, args: [expr] });
   }
-  function peg$f683(direction, chars, str) {
+  function peg$f791(direction, chars, str) {
     // ClickHouse simplifies TRIM with empty string to just the expression
     if (chars.kind === 'literal' && chars.type === 'String' && chars.value === '') {
       return str;
@@ -3507,24 +3859,24 @@ function peg$parse(input, options) {
     const fname = direction === 'LEADING' ? 'trimLeft' : (direction === 'TRAILING' ? 'trimRight' : 'trimBoth');
     return loc({ kind: 'functionCall', name: fname, args: [str, chars] });
   }
-  function peg$f684(needle, haystack) {
+  function peg$f792(needle, haystack) {
     return loc({ kind: 'functionCall', name: 'position', args: [haystack, needle] });
   }
-  function peg$f685(str) {
+  function peg$f793(str) {
     return loc({ kind: 'functionCall', name: 'toDate', args: [str] });
   }
-  function peg$f686(str) {
+  function peg$f794(str) {
     return loc({ kind: 'functionCall', name: 'toDateTime', args: [str] });
   }
-  function peg$f687(str) {
+  function peg$f795(str) {
     return loc({ kind: 'functionCall', name: 'toTime', args: [str] });
   }
-  function peg$f688(expr, name) {    return name;  }
-  function peg$f689(expr, alias, type) {
+  function peg$f796(expr, name) {    return name;  }
+  function peg$f797(expr, alias, type) {
     const innerExpr = alias !== null ? loc({ kind: 'alias', expr, alias }) : expr;
     return loc({ kind: 'castExpr', expr: innerExpr, type: type });
   }
-  function peg$f690(name, openComments, modifier, first, funcSettings, second, filter) {
+  function peg$f798(name, openComments, modifier, first, funcSettings, second, filter) {
     const modVal = modifier !== null ? modifier[0] : null;
     const modStr = Array.isArray(modVal) ? modVal[0] : modVal;
     const isDistinct = modStr !== null && modStr !== undefined && modStr.toString().toUpperCase() === 'DISTINCT';
@@ -3557,122 +3909,122 @@ function peg$parse(input, options) {
     }
     return call;
   }
-  function peg$f691(unit) {    return unit;  }
-  function peg$f692() {    return 'LEADING';  }
-  function peg$f693() {    return 'TRAILING';  }
-  function peg$f694() {    return 'BOTH';  }
-  function peg$f695(expr) {    return expr;  }
-  function peg$f696(head, tail) {    return head + tail.join("");  }
-  function peg$f697(head, tail) {    return head + tail.join("");  }
-  function peg$f698(chars) {    return chars.join("");  }
-  function peg$f699(chars) {    return chars.join("");  }
-  function peg$f700(arg) {    return arg;  }
-  function peg$f701(head, tail) {
+  function peg$f799(unit) {    return unit;  }
+  function peg$f800() {    return 'LEADING';  }
+  function peg$f801() {    return 'TRAILING';  }
+  function peg$f802() {    return 'BOTH';  }
+  function peg$f803(expr) {    return expr;  }
+  function peg$f804(head, tail) {    return head + tail.join("");  }
+  function peg$f805(head, tail) {    return head + tail.join("");  }
+  function peg$f806(chars) {    return chars.join("");  }
+  function peg$f807(chars) {    return chars.join("");  }
+  function peg$f808(arg) {    return arg;  }
+  function peg$f809(head, tail) {
     return buildCommaList(head, tail);
   }
-  function peg$f702(params, body) {
+  function peg$f810(params, body) {
     return loc({ kind: 'lambdaExpr', params: params, body: body });
   }
-  function peg$f703(query) {
+  function peg$f811(query) {
     return loc({ kind: 'subqueryExpr', query: query });
   }
-  function peg$f704(name) {    return loc({ kind: 'columnRef', parts: [name] });  }
-  function peg$f705(head, tail) {
+  function peg$f812(name) {    return loc({ kind: 'columnRef', parts: [name] });  }
+  function peg$f813(head, tail) {
     return [head, ...tail];
   }
-  function peg$f706(name, rest) {
+  function peg$f814(name, rest) {
     return [name, ...rest];
   }
-  function peg$f707(name) {
+  function peg$f815(name) {
     return [name];
   }
-  function peg$f708(first, part) {    return part;  }
-  function peg$f709(first, rest, args) {
+  function peg$f816(first, part) {    return part;  }
+  function peg$f817(first, rest, args) {
     const name = [first, ...rest].join('.');
     return loc({ kind: 'functionCall', name, args: args !== null ? args : [] });
   }
-  function peg$f710(first, part) {    return part;  }
-  function peg$f711(first, rest) {
+  function peg$f818(first, part) {    return part;  }
+  function peg$f819(first, rest) {
     return loc({ kind: 'columnRef', parts: [first, ...rest] });
   }
-  function peg$f712(name) {    return loc({ kind: 'columnRef', parts: [name] });  }
-  function peg$f713(name) {    return loc({ kind: 'columnRef', parts: [name] });  }
-  function peg$f714(name, brackets) {    return "^" + name + (brackets !== null ? "[]" : "");  }
-  function peg$f715(name, brackets) {    return name + (brackets !== null ? "[]" : "");  }
-  function peg$f716(first, part) {    return part;  }
-  function peg$f717(first, rest, transformers) {
+  function peg$f820(name) {    return loc({ kind: 'columnRef', parts: [name] });  }
+  function peg$f821(name) {    return loc({ kind: 'columnRef', parts: [name] });  }
+  function peg$f822(name, brackets) {    return "^" + name + (brackets !== null ? "[]" : "");  }
+  function peg$f823(name, brackets) {    return name + (brackets !== null ? "[]" : "");  }
+  function peg$f824(first, part) {    return part;  }
+  function peg$f825(first, rest, transformers) {
     const result = loc({ kind: 'qualifiedAsterisk', parts: [first, ...rest] });
     if (transformers.length > 0) result.transformers = transformers.map((t) => t[1]);
     return result;
   }
-  function peg$f718(transformers) {
+  function peg$f826(transformers) {
     const result = loc({ kind: 'asterisk' });
     if (transformers.length > 0) result.transformers = transformers.map((t) => t[1]);
     return result;
   }
-  function peg$f719(cols) {
+  function peg$f827(cols) {
     return { kind: 'except', columns: cols, strict: true };
   }
-  function peg$f720(col) {
+  function peg$f828(col) {
     return { kind: 'except', columns: [col], strict: true };
   }
-  function peg$f721(cols) {
+  function peg$f829(cols) {
     return { kind: 'except', columns: cols };
   }
-  function peg$f722(str) {
+  function peg$f830(str) {
     return { kind: 'except', columns: [str.value], pattern: true };
   }
-  function peg$f723(str) {
+  function peg$f831(str) {
     return { kind: 'except', columns: [str.value], pattern: true };
   }
-  function peg$f724(col) {
+  function peg$f832(col) {
     return { kind: 'except', columns: [col] };
   }
-  function peg$f725(head, tail) {
+  function peg$f833(head, tail) {
     return [head, ...tail.map((t) => t[3])];
   }
-  function peg$f726(func) {
+  function peg$f834(func) {
     return { kind: 'apply', func: func };
   }
-  function peg$f727(func) {
+  function peg$f835(func) {
     return { kind: 'apply', func: func };
   }
-  function peg$f728(func) {
+  function peg$f836(func) {
     return { kind: 'apply', func: func };
   }
-  function peg$f729(name) {
+  function peg$f837(name) {
     return { kind: 'apply', func: loc({ kind: 'columnRef', parts: [name] }) };
   }
-  function peg$f730(items) {
+  function peg$f838(items) {
     return { kind: 'replace', items: items, strict: true };
   }
-  function peg$f731(item) {
+  function peg$f839(item) {
     return { kind: 'replace', items: [item], strict: true };
   }
-  function peg$f732(items) {
+  function peg$f840(items) {
     return { kind: 'replace', items: items };
   }
-  function peg$f733(item) {
+  function peg$f841(item) {
     return { kind: 'replace', items: [item] };
   }
-  function peg$f734(head, tail) {
+  function peg$f842(head, tail) {
     return [head, ...tail.map((t) => t[3])];
   }
-  function peg$f735(expr, alias) {
+  function peg$f843(expr, alias) {
     return { expr, alias };
   }
-  function peg$f736(first, part) {    return part;  }
-  function peg$f737(first, rest, args, transformers) {
+  function peg$f844(first, part) {    return part;  }
+  function peg$f845(first, rest, args, transformers) {
     const qualPath = [first, ...rest];
     const result = loc({ kind: 'columnsExpr', args, qualifier: qualPath.join('.') });
     if (transformers.length > 0) result.transformers = transformers.map((t) => t[1]);
     return result;
   }
-  function peg$f738(args, head, rest) {
+  function peg$f846(args, head, rest) {
     const transformers = [head, ...rest.map((t) => t[1])];
     return loc({ kind: 'columnsExpr', args, transformers });
   }
-  function peg$f739(digits) {
+  function peg$f847(digits) {
     const normalized = digits.replace(/_/g, '').replace(/^0+/, '') || '0';
     const UINT64_MAX = BigInt('18446744073709551615');
     if (normalized.length > 20 || (normalized.length >= 20 && BigInt(normalized) > UINT64_MAX)) {
@@ -3681,10 +4033,10 @@ function peg$parse(input, options) {
     }
     return loc({ kind: 'literal', type: 'UInt64', value: normalized });
   }
-  function peg$f740(chars) {
+  function peg$f848(chars) {
     return loc({ kind: 'literal', type: 'String', value: chars.join('') });
   }
-  function peg$f741(chars) {
+  function peg$f849(chars) {
     // Collect consecutive hex byte objects and decode as UTF-8
     const parts = [];
     let hexBuf = [];
@@ -3704,64 +4056,64 @@ function peg$parse(input, options) {
     }
     return loc({ kind: 'literal', type: 'String', value: parts.join('') });
   }
-  function peg$f742() {    return "'";  }
-  function peg$f743() {    return '\x07';  }
-  function peg$f744() {    return '\x1b';  }
-  function peg$f745() {    return '\x0b';  }
-  function peg$f746() {    return '\\\\';  }
-  function peg$f747() {    return '\\b';  }
-  function peg$f748() {    return '\\f';  }
-  function peg$f749() {    return '\\n';  }
-  function peg$f750() {    return '\\r';  }
-  function peg$f751() {    return '\\t';  }
-  function peg$f752() {    return '\\0';  }
-  function peg$f753() {    return "'";  }
-  function peg$f754() {    return '"';  }
-  function peg$f755(hi, lo) {
+  function peg$f850() {    return "'";  }
+  function peg$f851() {    return '\x07';  }
+  function peg$f852() {    return '\x1b';  }
+  function peg$f853() {    return '\x0b';  }
+  function peg$f854() {    return '\\\\';  }
+  function peg$f855() {    return '\\b';  }
+  function peg$f856() {    return '\\f';  }
+  function peg$f857() {    return '\\n';  }
+  function peg$f858() {    return '\\r';  }
+  function peg$f859() {    return '\\t';  }
+  function peg$f860() {    return '\\0';  }
+  function peg$f861() {    return "'";  }
+  function peg$f862() {    return '"';  }
+  function peg$f863(hi, lo) {
     return { hexByte: parseInt(hi + lo, 16) };
   }
-  function peg$f756(c) {    return '\\\\' + c;  }
-  function peg$f757(c) {    return '\\\\' + c;  }
-  function peg$f758() {    return text();  }
-  function peg$f759() {    return '\\\\';  }
-  function peg$f760() {    return '\\\\';  }
-  function peg$f761(c) {    return c;  }
-  function peg$f762(name) {
+  function peg$f864(c) {    return '\\\\' + c;  }
+  function peg$f865(c) {    return '\\\\' + c;  }
+  function peg$f866() {    return text();  }
+  function peg$f867() {    return '\\\\';  }
+  function peg$f868() {    return '\\\\';  }
+  function peg$f869(c) {    return c;  }
+  function peg$f870(name) {
     return loc({ kind: 'queryParam', name: name, type: 'Identifier' });
   }
-  function peg$f763(db, table) {
+  function peg$f871(db, table) {
     return loc({ kind: 'tableRef', database: db, table: table });
   }
-  function peg$f764(table) {
+  function peg$f872(table) {
     return loc({ kind: 'tableRef', table: table });
   }
-  function peg$f765(word) {    return !KEYWORDS.has(word.toUpperCase());  }
-  function peg$f766(word) {    return word;  }
-  function peg$f767(chars) {    return chars.join("");  }
-  function peg$f768(chars) {    return chars.join("");  }
-  function peg$f769(chars) {    return chars;  }
-  function peg$f770(word) {    return word;  }
-  function peg$f771(chars) {    return chars.join("");  }
-  function peg$f772(chars) {    return chars.join("");  }
-  function peg$f773(chars) {    return chars;  }
-  function peg$f774(head, tail) {    return head + tail.join("");  }
-  function peg$f775(head, tail) {    return head + tail.join("");  }
-  function peg$f776(chars) {    return chars.join("");  }
-  function peg$f777(chars) {    return chars.join("");  }
-  function peg$f778(chars) {    return chars;  }
-  function peg$f779() {    return '"';  }
-  function peg$f780() {    return '"';  }
-  function peg$f781() {    return '\\';  }
-  function peg$f782(c) {    return '\\' + c;  }
-  function peg$f783() {    return text();  }
-  function peg$f784() {    return '`';  }
-  function peg$f785(hex) {    return Buffer.from([parseInt(hex, 16)]).toString('utf8');  }
-  function peg$f786() {    return '\0';  }
-  function peg$f787(char) {    return char;  }
-  function peg$f788() {    return text();  }
-  function peg$f789(s) {    return s;  }
-  function peg$f790(s) {    return s;  }
-  function peg$f791(trailing, newlineContent) {
+  function peg$f873(word) {    return !KEYWORDS.has(word.toUpperCase());  }
+  function peg$f874(word) {    return word;  }
+  function peg$f875(chars) {    return chars.join("");  }
+  function peg$f876(chars) {    return chars.join("");  }
+  function peg$f877(chars) {    return chars;  }
+  function peg$f878(word) {    return word;  }
+  function peg$f879(chars) {    return chars.join("");  }
+  function peg$f880(chars) {    return chars.join("");  }
+  function peg$f881(chars) {    return chars;  }
+  function peg$f882(head, tail) {    return head + tail.join("");  }
+  function peg$f883(head, tail) {    return head + tail.join("");  }
+  function peg$f884(chars) {    return chars.join("");  }
+  function peg$f885(chars) {    return chars.join("");  }
+  function peg$f886(chars) {    return chars;  }
+  function peg$f887() {    return '"';  }
+  function peg$f888() {    return '"';  }
+  function peg$f889() {    return '\\';  }
+  function peg$f890(c) {    return '\\' + c;  }
+  function peg$f891() {    return text();  }
+  function peg$f892() {    return '`';  }
+  function peg$f893(hex) {    return Buffer.from([parseInt(hex, 16)]).toString('utf8');  }
+  function peg$f894() {    return '\0';  }
+  function peg$f895(char) {    return char;  }
+  function peg$f896() {    return text();  }
+  function peg$f897(s) {    return s;  }
+  function peg$f898(s) {    return s;  }
+  function peg$f899(trailing, newlineContent) {
     const leading = [];
     for (const nc of newlineContent) {
       for (const item of nc) {
@@ -3770,17 +4122,17 @@ function peg$parse(input, options) {
     }
     return { trailing, leading };
   }
-  function peg$f792() {    return null;  }
-  function peg$f793(items) {
+  function peg$f900() {    return null;  }
+  function peg$f901(items) {
     return items.filter((item) => item !== null);
   }
-  function peg$f794() {    return null;  }
-  function peg$f795(items) {
+  function peg$f902() {    return null;  }
+  function peg$f903(items) {
     return items;
   }
-  function peg$f796() {    return text();  }
-  function peg$f797() {    return text();  }
-  function peg$f798() {    return text();  }
+  function peg$f904() {    return text();  }
+  function peg$f905() {    return text();  }
+  function peg$f906() {    return text();  }
   let peg$currPos = options.peg$currPos | 0;
   let peg$savedPos = peg$currPos;
   const peg$posDetailsCache = [{ line: 1, column: 1 }];
@@ -3956,7 +4308,7 @@ function peg$parse(input, options) {
   function peg$parseStatements() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 0;
+    const key = peg$currPos * 508 + 0;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -4003,7 +4355,7 @@ function peg$parse(input, options) {
   function peg$parseStatementsRestEntry() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 1;
+    const key = peg$currPos * 508 + 1;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -4045,7 +4397,7 @@ function peg$parse(input, options) {
   function peg$parseStatementsTrailing() {
     let s0, s1, s2;
 
-    const key = peg$currPos * 466 + 2;
+    const key = peg$currPos * 508 + 2;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -4079,7 +4431,7 @@ function peg$parse(input, options) {
   function peg$parseEmptyStatementRun() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 3;
+    const key = peg$currPos * 508 + 3;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -4137,7 +4489,7 @@ function peg$parse(input, options) {
   function peg$parseTopLevelStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 4;
+    const key = peg$currPos * 508 + 4;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -4152,117 +4504,132 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$parseCreateStatement();
         if (s0 === peg$FAILED) {
-          s0 = peg$parseAlterStatement();
+          s0 = peg$parseAlterAccessStatement();
           if (s0 === peg$FAILED) {
-            s0 = peg$parseSetStatement();
+            s0 = peg$parseAlterStatement();
             if (s0 === peg$FAILED) {
-              s0 = peg$parseUseStatement();
+              s0 = peg$parseSetStatement();
               if (s0 === peg$FAILED) {
-                s0 = peg$parseSystemStatement();
+                s0 = peg$parseTransactionControlStatement();
                 if (s0 === peg$FAILED) {
-                  s0 = peg$parseInsertStatement();
+                  s0 = peg$parseUseStatement();
                   if (s0 === peg$FAILED) {
-                    s0 = peg$parseDropStatement();
+                    s0 = peg$parseSystemStatement();
                     if (s0 === peg$FAILED) {
-                      s0 = peg$parseTruncateStatement();
+                      s0 = peg$parseInsertStatement();
                       if (s0 === peg$FAILED) {
-                        s0 = peg$parseOptimizeStatement();
+                        s0 = peg$parseDropStatement();
                         if (s0 === peg$FAILED) {
-                          s0 = peg$parseDescribeStatement();
+                          s0 = peg$parseUndropStatement();
                           if (s0 === peg$FAILED) {
-                            s0 = peg$parseShowCreateStatement();
+                            s0 = peg$parseBackupStatement();
                             if (s0 === peg$FAILED) {
-                              s0 = peg$parseDetachStatement();
+                              s0 = peg$parseGrantStatement();
                               if (s0 === peg$FAILED) {
-                                s0 = peg$parseDeleteStatement();
+                                s0 = peg$parseTruncateStatement();
                                 if (s0 === peg$FAILED) {
-                                  s0 = peg$parseUpdateStatement();
+                                  s0 = peg$parseOptimizeStatement();
                                   if (s0 === peg$FAILED) {
-                                    s0 = peg$parseCheckStatement();
+                                    s0 = peg$parseDescribeStatement();
                                     if (s0 === peg$FAILED) {
-                                      s0 = peg$parseAttachStatement();
+                                      s0 = peg$parseShowCreateStatement();
                                       if (s0 === peg$FAILED) {
-                                        s0 = peg$parseRenameStatement();
+                                        s0 = peg$parseShowStatement();
                                         if (s0 === peg$FAILED) {
-                                          s0 = peg$parseExistsStatement();
+                                          s0 = peg$parseDetachStatement();
                                           if (s0 === peg$FAILED) {
-                                            s0 = peg$parseKillStatement();
+                                            s0 = peg$parseDeleteStatement();
                                             if (s0 === peg$FAILED) {
-                                              s0 = peg$parseExecuteAsStatement();
+                                              s0 = peg$parseUpdateStatement();
                                               if (s0 === peg$FAILED) {
-                                                s0 = peg$parseOpaqueStatement();
+                                                s0 = peg$parseCheckStatement();
                                                 if (s0 === peg$FAILED) {
-                                                  s0 = peg$currPos;
-                                                  s1 = peg$parseUnionQuery();
-                                                  if (s1 !== peg$FAILED) {
-                                                    s2 = peg$currPos;
-                                                    s3 = peg$parse_();
-                                                    s4 = peg$parseIntoOutfileClause();
-                                                    if (s4 !== peg$FAILED) {
-                                                      s3 = [s3, s4];
-                                                      s2 = s3;
-                                                    } else {
-                                                      peg$currPos = s2;
-                                                      s2 = peg$FAILED;
-                                                    }
-                                                    if (s2 === peg$FAILED) {
-                                                      s2 = null;
-                                                    }
-                                                    s3 = peg$currPos;
-                                                    s4 = peg$parse_();
-                                                    s5 = peg$parseSettingsClause();
-                                                    if (s5 !== peg$FAILED) {
-                                                      s4 = [s4, s5];
-                                                      s3 = s4;
-                                                    } else {
-                                                      peg$currPos = s3;
-                                                      s3 = peg$FAILED;
-                                                    }
-                                                    if (s3 === peg$FAILED) {
-                                                      s3 = null;
-                                                    }
-                                                    s4 = peg$currPos;
-                                                    s5 = peg$parse_();
-                                                    s6 = peg$parseFormatClause();
-                                                    if (s6 !== peg$FAILED) {
-                                                      s5 = [s5, s6];
-                                                      s4 = s5;
-                                                    } else {
-                                                      peg$currPos = s4;
-                                                      s4 = peg$FAILED;
-                                                    }
-                                                    if (s4 === peg$FAILED) {
-                                                      s4 = null;
-                                                    }
-                                                    s5 = [];
-                                                    s6 = peg$currPos;
-                                                    s7 = peg$parse_();
-                                                    s8 = peg$parseSettingsClause();
-                                                    if (s8 !== peg$FAILED) {
-                                                      s7 = [s7, s8];
-                                                      s6 = s7;
-                                                    } else {
-                                                      peg$currPos = s6;
-                                                      s6 = peg$FAILED;
-                                                    }
-                                                    while (s6 !== peg$FAILED) {
-                                                      s5.push(s6);
-                                                      s6 = peg$currPos;
-                                                      s7 = peg$parse_();
-                                                      s8 = peg$parseSettingsClause();
-                                                      if (s8 !== peg$FAILED) {
-                                                        s7 = [s7, s8];
-                                                        s6 = s7;
-                                                      } else {
-                                                        peg$currPos = s6;
-                                                        s6 = peg$FAILED;
+                                                  s0 = peg$parseAttachStatement();
+                                                  if (s0 === peg$FAILED) {
+                                                    s0 = peg$parseRenameStatement();
+                                                    if (s0 === peg$FAILED) {
+                                                      s0 = peg$parseExistsStatement();
+                                                      if (s0 === peg$FAILED) {
+                                                        s0 = peg$parseKillStatement();
+                                                        if (s0 === peg$FAILED) {
+                                                          s0 = peg$parseExecuteAsStatement();
+                                                          if (s0 === peg$FAILED) {
+                                                            s0 = peg$currPos;
+                                                            s1 = peg$parseUnionQuery();
+                                                            if (s1 !== peg$FAILED) {
+                                                              s2 = peg$currPos;
+                                                              s3 = peg$parse_();
+                                                              s4 = peg$parseIntoOutfileClause();
+                                                              if (s4 !== peg$FAILED) {
+                                                                s3 = [s3, s4];
+                                                                s2 = s3;
+                                                              } else {
+                                                                peg$currPos = s2;
+                                                                s2 = peg$FAILED;
+                                                              }
+                                                              if (s2 === peg$FAILED) {
+                                                                s2 = null;
+                                                              }
+                                                              s3 = peg$currPos;
+                                                              s4 = peg$parse_();
+                                                              s5 = peg$parseSettingsClause();
+                                                              if (s5 !== peg$FAILED) {
+                                                                s4 = [s4, s5];
+                                                                s3 = s4;
+                                                              } else {
+                                                                peg$currPos = s3;
+                                                                s3 = peg$FAILED;
+                                                              }
+                                                              if (s3 === peg$FAILED) {
+                                                                s3 = null;
+                                                              }
+                                                              s4 = peg$currPos;
+                                                              s5 = peg$parse_();
+                                                              s6 = peg$parseFormatClause();
+                                                              if (s6 !== peg$FAILED) {
+                                                                s5 = [s5, s6];
+                                                                s4 = s5;
+                                                              } else {
+                                                                peg$currPos = s4;
+                                                                s4 = peg$FAILED;
+                                                              }
+                                                              if (s4 === peg$FAILED) {
+                                                                s4 = null;
+                                                              }
+                                                              s5 = [];
+                                                              s6 = peg$currPos;
+                                                              s7 = peg$parse_();
+                                                              s8 = peg$parseSettingsClause();
+                                                              if (s8 !== peg$FAILED) {
+                                                                s7 = [s7, s8];
+                                                                s6 = s7;
+                                                              } else {
+                                                                peg$currPos = s6;
+                                                                s6 = peg$FAILED;
+                                                              }
+                                                              while (s6 !== peg$FAILED) {
+                                                                s5.push(s6);
+                                                                s6 = peg$currPos;
+                                                                s7 = peg$parse_();
+                                                                s8 = peg$parseSettingsClause();
+                                                                if (s8 !== peg$FAILED) {
+                                                                  s7 = [s7, s8];
+                                                                  s6 = s7;
+                                                                } else {
+                                                                  peg$currPos = s6;
+                                                                  s6 = peg$FAILED;
+                                                                }
+                                                              }
+                                                              peg$savedPos = s0;
+                                                              s0 = peg$f5(s1, s2, s3, s4, s5);
+                                                            } else {
+                                                              peg$currPos = s0;
+                                                              s0 = peg$FAILED;
+                                                            }
+                                                          }
+                                                        }
                                                       }
                                                     }
-                                                    peg$savedPos = s0;
-                                                    s0 = peg$f5(s1, s2, s3, s4, s5);
-                                                  } else {
-                                                    peg$currPos = s0;
-                                                    s0 = peg$FAILED;
                                                   }
                                                 }
                                               }
@@ -4296,7 +4663,7 @@ function peg$parse(input, options) {
   function peg$parseIntoOutfileClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
 
-    const key = peg$currPos * 466 + 5;
+    const key = peg$currPos * 508 + 5;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -4431,7 +4798,7 @@ function peg$parse(input, options) {
   function peg$parseExecuteAsStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 6;
+    const key = peg$currPos * 508 + 6;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -4529,9 +4896,6 @@ function peg$parse(input, options) {
                                             s9 = peg$parseCreateStatement();
                                             if (s9 === peg$FAILED) {
                                               s9 = peg$parseUnionQuery();
-                                              if (s9 === peg$FAILED) {
-                                                s9 = peg$parseOpaqueStatement();
-                                              }
                                             }
                                           }
                                         }
@@ -4584,7 +4948,7 @@ function peg$parse(input, options) {
   function peg$parseSetStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;
 
-    const key = peg$currPos * 466 + 7;
+    const key = peg$currPos * 508 + 7;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -4840,7 +5204,7 @@ function peg$parse(input, options) {
                       }
                       if (s13 !== peg$FAILED) {
                         s14 = peg$parse_();
-                        s15 = peg$parseSetRoleUserList();
+                        s15 = peg$parseAliasNameList();
                         if (s15 !== peg$FAILED) {
                           peg$savedPos = s0;
                           s0 = peg$f9(s10, s15);
@@ -4939,7 +5303,7 @@ function peg$parse(input, options) {
   function peg$parseSetRoleList() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 8;
+    const key = peg$currPos * 508 + 8;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -5002,7 +5366,7 @@ function peg$parse(input, options) {
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
-            s8 = peg$parseSetRoleNameList();
+            s8 = peg$parseAliasNameList();
             if (s8 !== peg$FAILED) {
               s4 = [s4, s5, s6, s7, s8];
               s3 = s4;
@@ -5070,7 +5434,7 @@ function peg$parse(input, options) {
       }
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
-        s1 = peg$parseSetRoleNameList();
+        s1 = peg$parseAliasNameList();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
           s1 = peg$f13(s1);
@@ -5084,10 +5448,10 @@ function peg$parse(input, options) {
     return s0;
   }
 
-  function peg$parseSetRoleNameList() {
+  function peg$parseTransactionControlStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 9;
+    const key = peg$currPos * 508 + 9;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -5097,48 +5461,68 @@ function peg$parse(input, options) {
     }
 
     s0 = peg$currPos;
-    s1 = peg$parseAliasName();
+    s1 = input.substr(peg$currPos, 5);
+    if (s1.toLowerCase() === peg$c15) {
+      peg$currPos += (5);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e17); }
+    }
+    if (s1 === peg$FAILED) {
+      s1 = input.substr(peg$currPos, 5);
+      if (s1.toLowerCase() === peg$c16) {
+        peg$currPos += (5);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e18); }
+      }
+    }
     if (s1 !== peg$FAILED) {
-      s2 = [];
-      s3 = peg$currPos;
-      s4 = peg$parse_();
-      if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
         peg$currPos++;
       } else {
-        s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
       }
-      if (s5 !== peg$FAILED) {
-        s6 = peg$parse_();
-        s7 = peg$parseAliasName();
-        if (s7 !== peg$FAILED) {
-          s4 = [s4, s5, s6, s7];
-          s3 = s4;
-        } else {
-          peg$currPos = s3;
-          s3 = peg$FAILED;
-        }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
       } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
+        peg$currPos = s2;
+        s2 = peg$FAILED;
       }
-      while (s3 !== peg$FAILED) {
-        s2.push(s3);
+      if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
         s4 = peg$parse_();
-        if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
-          peg$currPos++;
+        s5 = input.substr(peg$currPos, 11);
+        if (s5.toLowerCase() === peg$c7) {
+          peg$currPos += (11);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e8); }
         }
         if (s5 !== peg$FAILED) {
-          s6 = peg$parse_();
-          s7 = peg$parseAliasName();
-          if (s7 !== peg$FAILED) {
-            s4 = [s4, s5, s6, s7];
+          s6 = peg$currPos;
+          peg$silentFails++;
+          s7 = input.charAt(peg$currPos);
+          if (peg$r0.test(s7)) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s7 === peg$FAILED) {
+            s6 = undefined;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            s4 = [s4, s5, s6];
             s3 = s4;
           } else {
             peg$currPos = s3;
@@ -5148,89 +5532,94 @@ function peg$parse(input, options) {
           peg$currPos = s3;
           s3 = peg$FAILED;
         }
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        peg$savedPos = s0;
+        s0 = peg$f14();
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
       }
-      peg$savedPos = s0;
-      s0 = peg$f14(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
     }
-
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
-
-    return s0;
-  }
-
-  function peg$parseSetRoleUserList() {
-    let s0, s1, s2, s3, s4, s5, s6, s7;
-
-    const key = peg$currPos * 466 + 10;
-    const cached = peg$resultsCache[key];
-
-    if (cached) {
-      peg$currPos = cached.nextPos;
-
-      return cached.result;
-    }
-
-    s0 = peg$currPos;
-    s1 = peg$parseAliasName();
-    if (s1 !== peg$FAILED) {
-      s2 = [];
-      s3 = peg$currPos;
-      s4 = peg$parse_();
-      if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
-        peg$currPos++;
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = input.substr(peg$currPos, 6);
+      if (s1.toLowerCase() === peg$c17) {
+        peg$currPos += (6);
       } else {
-        s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e19); }
       }
-      if (s5 !== peg$FAILED) {
-        s6 = peg$parse_();
-        s7 = peg$parseAliasName();
-        if (s7 !== peg$FAILED) {
-          s4 = [s4, s5, s6, s7];
-          s3 = s4;
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r0.test(s3)) {
+          peg$currPos++;
         } else {
-          peg$currPos = s3;
           s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f15();
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
         }
       } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
+        peg$currPos = s0;
+        s0 = peg$FAILED;
       }
-      while (s3 !== peg$FAILED) {
-        s2.push(s3);
-        s3 = peg$currPos;
-        s4 = peg$parse_();
-        if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
-          peg$currPos++;
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = input.substr(peg$currPos, 8);
+        if (s1.toLowerCase() === peg$c18) {
+          peg$currPos += (8);
         } else {
-          s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e20); }
         }
-        if (s5 !== peg$FAILED) {
-          s6 = peg$parse_();
-          s7 = peg$parseAliasName();
-          if (s7 !== peg$FAILED) {
-            s4 = [s4, s5, s6, s7];
-            s3 = s4;
+        if (s1 !== peg$FAILED) {
+          s2 = peg$currPos;
+          peg$silentFails++;
+          s3 = input.charAt(peg$currPos);
+          if (peg$r0.test(s3)) {
+            peg$currPos++;
           } else {
-            peg$currPos = s3;
             s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s3 === peg$FAILED) {
+            s2 = undefined;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+          if (s2 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f16();
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
           }
         } else {
-          peg$currPos = s3;
-          s3 = peg$FAILED;
+          peg$currPos = s0;
+          s0 = peg$FAILED;
         }
       }
-      peg$savedPos = s0;
-      s0 = peg$f15(s1, s2);
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
     }
 
     peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5241,7 +5630,7 @@ function peg$parse(input, options) {
   function peg$parseUseStatement() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 11;
+    const key = peg$currPos * 508 + 10;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -5252,11 +5641,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c16) {
+    if (s1.toLowerCase() === peg$c19) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e18); }
+      if (peg$silentFails === 0) { peg$fail(peg$e21); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -5283,7 +5672,7 @@ function peg$parse(input, options) {
         }
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f16(s4);
+          s0 = peg$f17(s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -5305,7 +5694,7 @@ function peg$parse(input, options) {
   function peg$parseSystemStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 12;
+    const key = peg$currPos * 508 + 11;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -5316,11 +5705,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c17) {
+    if (s1.toLowerCase() === peg$c20) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e19); }
+      if (peg$silentFails === 0) { peg$fail(peg$e22); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -5350,7 +5739,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e20); }
+          if (peg$silentFails === 0) { peg$fail(peg$e23); }
         }
         peg$silentFails--;
         if (s7 === peg$FAILED) {
@@ -5365,7 +5754,7 @@ function peg$parse(input, options) {
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e21); }
+            if (peg$silentFails === 0) { peg$fail(peg$e24); }
           }
           if (s7 !== peg$FAILED) {
             s6 = [s6, s7];
@@ -5389,7 +5778,7 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e20); }
+              if (peg$silentFails === 0) { peg$fail(peg$e23); }
             }
             peg$silentFails--;
             if (s7 === peg$FAILED) {
@@ -5404,7 +5793,7 @@ function peg$parse(input, options) {
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                if (peg$silentFails === 0) { peg$fail(peg$e24); }
               }
               if (s7 !== peg$FAILED) {
                 s6 = [s6, s7];
@@ -5428,7 +5817,7 @@ function peg$parse(input, options) {
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f17(s3);
+          s0 = peg$f18(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -5450,7 +5839,7 @@ function peg$parse(input, options) {
   function peg$parseAlterStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
 
-    const key = peg$currPos * 466 + 13;
+    const key = peg$currPos * 508 + 12;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -5461,11 +5850,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c18) {
+    if (s1.toLowerCase() === peg$c21) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e22); }
+      if (peg$silentFails === 0) { peg$fail(peg$e25); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -5488,11 +5877,11 @@ function peg$parse(input, options) {
         s3 = peg$parse_();
         s4 = peg$currPos;
         s5 = input.substr(peg$currPos, 9);
-        if (s5.toLowerCase() === peg$c19) {
+        if (s5.toLowerCase() === peg$c22) {
           peg$currPos += (9);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e23); }
+          if (peg$silentFails === 0) { peg$fail(peg$e26); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -5527,11 +5916,11 @@ function peg$parse(input, options) {
           s4 = null;
         }
         s5 = input.substr(peg$currPos, 5);
-        if (s5.toLowerCase() === peg$c20) {
+        if (s5.toLowerCase() === peg$c23) {
           peg$currPos += (5);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e24); }
+          if (peg$silentFails === 0) { peg$fail(peg$e27); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -5574,11 +5963,11 @@ function peg$parse(input, options) {
                 s13 = peg$currPos;
                 s14 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s15 = peg$c15;
+                  s15 = peg$c24;
                   peg$currPos++;
                 } else {
                   s15 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s15 !== peg$FAILED) {
                   s16 = peg$parse_();
@@ -5599,11 +5988,11 @@ function peg$parse(input, options) {
                   s13 = peg$currPos;
                   s14 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 44) {
-                    s15 = peg$c15;
+                    s15 = peg$c24;
                     peg$currPos++;
                   } else {
                     s15 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e28); }
                   }
                   if (s15 !== peg$FAILED) {
                     s16 = peg$parse_();
@@ -5660,7 +6049,7 @@ function peg$parse(input, options) {
                   s15 = null;
                 }
                 peg$savedPos = s0;
-                s0 = peg$f18(s8, s9, s11, s12, s13, s14, s15);
+                s0 = peg$f19(s8, s9, s11, s12, s13, s14, s15);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -5694,7 +6083,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommand() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 14;
+    const key = peg$currPos * 508 + 13;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -5705,11 +6094,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
@@ -5717,15 +6106,15 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s5 = peg$c22;
+          s5 = peg$c26;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f19(s3);
+          s0 = peg$f20(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -5750,7 +6139,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandInner() {
     let s0;
 
-    const key = peg$currPos * 466 + 15;
+    const key = peg$currPos * 508 + 14;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -5791,63 +6180,66 @@ function peg$parse(input, options) {
                                 if (s0 === peg$FAILED) {
                                   s0 = peg$parseAlterCommandModifyQuery();
                                   if (s0 === peg$FAILED) {
-                                    s0 = peg$parseAlterCommandModifyComment();
+                                    s0 = peg$parseAlterCommandModifyRefresh();
                                     if (s0 === peg$FAILED) {
-                                      s0 = peg$parseAlterCommandAddIndex();
+                                      s0 = peg$parseAlterCommandModifyComment();
                                       if (s0 === peg$FAILED) {
-                                        s0 = peg$parseAlterCommandDropIndex();
+                                        s0 = peg$parseAlterCommandAddIndex();
                                         if (s0 === peg$FAILED) {
-                                          s0 = peg$parseAlterCommandClearIndex();
+                                          s0 = peg$parseAlterCommandDropIndex();
                                           if (s0 === peg$FAILED) {
-                                            s0 = peg$parseAlterCommandMaterializeIndex();
+                                            s0 = peg$parseAlterCommandClearIndex();
                                             if (s0 === peg$FAILED) {
-                                              s0 = peg$parseAlterCommandAddProjection();
+                                              s0 = peg$parseAlterCommandMaterializeIndex();
                                               if (s0 === peg$FAILED) {
-                                                s0 = peg$parseAlterCommandDropProjection();
+                                                s0 = peg$parseAlterCommandAddProjection();
                                                 if (s0 === peg$FAILED) {
-                                                  s0 = peg$parseAlterCommandClearProjection();
+                                                  s0 = peg$parseAlterCommandDropProjection();
                                                   if (s0 === peg$FAILED) {
-                                                    s0 = peg$parseAlterCommandMaterializeProjection();
+                                                    s0 = peg$parseAlterCommandClearProjection();
                                                     if (s0 === peg$FAILED) {
-                                                      s0 = peg$parseAlterCommandAddConstraint();
+                                                      s0 = peg$parseAlterCommandMaterializeProjection();
                                                       if (s0 === peg$FAILED) {
-                                                        s0 = peg$parseAlterCommandDropConstraint();
+                                                        s0 = peg$parseAlterCommandAddConstraint();
                                                         if (s0 === peg$FAILED) {
-                                                          s0 = peg$parseAlterCommandAddStatistics();
+                                                          s0 = peg$parseAlterCommandDropConstraint();
                                                           if (s0 === peg$FAILED) {
-                                                            s0 = peg$parseAlterCommandDropStatistics();
+                                                            s0 = peg$parseAlterCommandAddStatistics();
                                                             if (s0 === peg$FAILED) {
-                                                              s0 = peg$parseAlterCommandClearStatistics();
+                                                              s0 = peg$parseAlterCommandDropStatistics();
                                                               if (s0 === peg$FAILED) {
-                                                                s0 = peg$parseAlterCommandModifyStatistics();
+                                                                s0 = peg$parseAlterCommandClearStatistics();
                                                                 if (s0 === peg$FAILED) {
-                                                                  s0 = peg$parseAlterCommandMaterializeStatistics();
+                                                                  s0 = peg$parseAlterCommandModifyStatistics();
                                                                   if (s0 === peg$FAILED) {
-                                                                    s0 = peg$parseAlterCommandUpdate();
+                                                                    s0 = peg$parseAlterCommandMaterializeStatistics();
                                                                     if (s0 === peg$FAILED) {
-                                                                      s0 = peg$parseAlterCommandDelete();
+                                                                      s0 = peg$parseAlterCommandUpdate();
                                                                       if (s0 === peg$FAILED) {
-                                                                        s0 = peg$parseAlterCommandDropPartition();
+                                                                        s0 = peg$parseAlterCommandDelete();
                                                                         if (s0 === peg$FAILED) {
-                                                                          s0 = peg$parseAlterCommandDropDetachedPartition();
+                                                                          s0 = peg$parseAlterCommandDropPartition();
                                                                           if (s0 === peg$FAILED) {
-                                                                            s0 = peg$parseAlterCommandAttachPartition();
+                                                                            s0 = peg$parseAlterCommandDropDetachedPartition();
                                                                             if (s0 === peg$FAILED) {
-                                                                              s0 = peg$parseAlterCommandReplacePartition();
+                                                                              s0 = peg$parseAlterCommandAttachPartition();
                                                                               if (s0 === peg$FAILED) {
-                                                                                s0 = peg$parseAlterCommandMovePartition();
+                                                                                s0 = peg$parseAlterCommandReplacePartition();
                                                                                 if (s0 === peg$FAILED) {
-                                                                                  s0 = peg$parseAlterCommandFetchPartition();
+                                                                                  s0 = peg$parseAlterCommandMovePartition();
                                                                                   if (s0 === peg$FAILED) {
-                                                                                    s0 = peg$parseAlterCommandFreezePartition();
+                                                                                    s0 = peg$parseAlterCommandFetchPartition();
                                                                                     if (s0 === peg$FAILED) {
-                                                                                      s0 = peg$parseAlterCommandFreezeAll();
+                                                                                      s0 = peg$parseAlterCommandFreezePartition();
                                                                                       if (s0 === peg$FAILED) {
-                                                                                        s0 = peg$parseAlterCommandApplyDeletedMask();
+                                                                                        s0 = peg$parseAlterCommandFreezeAll();
                                                                                         if (s0 === peg$FAILED) {
-                                                                                          s0 = peg$parseAlterCommandApplyPatches();
+                                                                                          s0 = peg$parseAlterCommandApplyDeletedMask();
                                                                                           if (s0 === peg$FAILED) {
-                                                                                            s0 = peg$parseAlterCommandRewriteParts();
+                                                                                            s0 = peg$parseAlterCommandApplyPatches();
+                                                                                            if (s0 === peg$FAILED) {
+                                                                                              s0 = peg$parseAlterCommandRewriteParts();
+                                                                                            }
                                                                                           }
                                                                                         }
                                                                                       }
@@ -5901,7 +6293,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandAddColumn() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 16;
+    const key = peg$currPos * 508 + 15;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -5912,11 +6304,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c23) {
+    if (s1.toLowerCase() === peg$c27) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e27); }
+      if (peg$silentFails === 0) { peg$fail(peg$e31); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -5938,11 +6330,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c24) {
+        if (s4.toLowerCase() === peg$c28) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+          if (peg$silentFails === 0) { peg$fail(peg$e32); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -5965,11 +6357,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -5991,11 +6383,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 3);
-                if (s11.toLowerCase() === peg$c26) {
+                if (s11.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -6017,11 +6409,11 @@ function peg$parse(input, options) {
                   if (s12 !== peg$FAILED) {
                     s13 = peg$parse_();
                     s14 = input.substr(peg$currPos, 6);
-                    if (s14.toLowerCase() === peg$c27) {
+                    if (s14.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s14 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s14 !== peg$FAILED) {
                       s15 = peg$currPos;
@@ -6076,11 +6468,11 @@ function peg$parse(input, options) {
               s9 = peg$currPos;
               s10 = peg$parse_();
               s11 = input.substr(peg$currPos, 5);
-              if (s11.toLowerCase() === peg$c28) {
+              if (s11.toLowerCase() === peg$c32) {
                 peg$currPos += (5);
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e32); }
+                if (peg$silentFails === 0) { peg$fail(peg$e36); }
               }
               if (s11 !== peg$FAILED) {
                 s12 = peg$currPos;
@@ -6121,11 +6513,11 @@ function peg$parse(input, options) {
                 s9 = peg$currPos;
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 5);
-                if (s11.toLowerCase() === peg$c29) {
+                if (s11.toLowerCase() === peg$c33) {
                   peg$currPos += (5);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e33); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e37); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -6160,7 +6552,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f20(s6, s8, s9);
+              s0 = peg$f21(s6, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -6190,7 +6582,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandDropColumn() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 17;
+    const key = peg$currPos * 508 + 16;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -6201,11 +6593,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c30) {
+    if (s1.toLowerCase() === peg$c34) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e34); }
+      if (peg$silentFails === 0) { peg$fail(peg$e38); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -6227,11 +6619,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c24) {
+        if (s4.toLowerCase() === peg$c28) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+          if (peg$silentFails === 0) { peg$fail(peg$e32); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -6254,11 +6646,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -6280,11 +6672,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -6342,7 +6734,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f21(s6, s8, s9);
+              s0 = peg$f22(s6, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -6372,7 +6764,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandClearColumn() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 18;
+    const key = peg$currPos * 508 + 17;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -6383,11 +6775,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c31) {
+    if (s1.toLowerCase() === peg$c35) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e35); }
+      if (peg$silentFails === 0) { peg$fail(peg$e39); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -6409,11 +6801,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c24) {
+        if (s4.toLowerCase() === peg$c28) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+          if (peg$silentFails === 0) { peg$fail(peg$e32); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -6436,11 +6828,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -6462,11 +6854,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -6524,7 +6916,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f22(s6, s8, s9);
+              s0 = peg$f23(s6, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -6554,7 +6946,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandModifyColumn() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 19;
+    const key = peg$currPos * 508 + 18;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -6565,19 +6957,19 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c32) {
+    if (s1.toLowerCase() === peg$c36) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e36); }
+      if (peg$silentFails === 0) { peg$fail(peg$e40); }
     }
     if (s1 === peg$FAILED) {
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c18) {
+      if (s1.toLowerCase() === peg$c21) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e22); }
+        if (peg$silentFails === 0) { peg$fail(peg$e25); }
       }
     }
     if (s1 !== peg$FAILED) {
@@ -6600,11 +6992,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c24) {
+        if (s4.toLowerCase() === peg$c28) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+          if (peg$silentFails === 0) { peg$fail(peg$e32); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -6627,11 +7019,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -6653,11 +7045,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -6703,11 +7095,11 @@ function peg$parse(input, options) {
             if (s8 !== peg$FAILED) {
               s9 = peg$parse_();
               s10 = input.substr(peg$currPos, 4);
-              if (s10.toLowerCase() === peg$c33) {
+              if (s10.toLowerCase() === peg$c37) {
                 peg$currPos += (4);
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e37); }
+                if (peg$silentFails === 0) { peg$fail(peg$e41); }
               }
               if (s10 !== peg$FAILED) {
                 s11 = peg$currPos;
@@ -6731,7 +7123,7 @@ function peg$parse(input, options) {
                   s13 = peg$parseColumnDataType();
                   if (s13 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f23(s6, s8, s13);
+                    s0 = peg$f24(s6, s8, s13);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -6767,19 +7159,19 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c32) {
+      if (s1.toLowerCase() === peg$c36) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e36); }
+        if (peg$silentFails === 0) { peg$fail(peg$e40); }
       }
       if (s1 === peg$FAILED) {
         s1 = input.substr(peg$currPos, 5);
-        if (s1.toLowerCase() === peg$c18) {
+        if (s1.toLowerCase() === peg$c21) {
           peg$currPos += (5);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e22); }
+          if (peg$silentFails === 0) { peg$fail(peg$e25); }
         }
       }
       if (s1 !== peg$FAILED) {
@@ -6802,11 +7194,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 6);
-          if (s4.toLowerCase() === peg$c24) {
+          if (s4.toLowerCase() === peg$c28) {
             peg$currPos += (6);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e28); }
+            if (peg$silentFails === 0) { peg$fail(peg$e32); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -6829,11 +7221,11 @@ function peg$parse(input, options) {
               s6 = peg$currPos;
               s7 = peg$parse_();
               s8 = input.substr(peg$currPos, 2);
-              if (s8.toLowerCase() === peg$c25) {
+              if (s8.toLowerCase() === peg$c29) {
                 peg$currPos += (2);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                if (peg$silentFails === 0) { peg$fail(peg$e33); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -6855,11 +7247,11 @@ function peg$parse(input, options) {
                 if (s9 !== peg$FAILED) {
                   s10 = peg$parse_();
                   s11 = input.substr(peg$currPos, 6);
-                  if (s11.toLowerCase() === peg$c27) {
+                  if (s11.toLowerCase() === peg$c31) {
                     peg$currPos += (6);
                   } else {
                     s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e35); }
                   }
                   if (s11 !== peg$FAILED) {
                     s12 = peg$currPos;
@@ -6906,11 +7298,11 @@ function peg$parse(input, options) {
                 s9 = peg$currPos;
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c34) {
+                if (s11.toLowerCase() === peg$c38) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e38); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e42); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -6966,11 +7358,11 @@ function peg$parse(input, options) {
                 s11 = peg$currPos;
                 s12 = peg$parse_();
                 s13 = input.substr(peg$currPos, 5);
-                if (s13.toLowerCase() === peg$c28) {
+                if (s13.toLowerCase() === peg$c32) {
                   peg$currPos += (5);
                 } else {
                   s13 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e32); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e36); }
                 }
                 if (s13 !== peg$FAILED) {
                   s14 = peg$currPos;
@@ -7011,11 +7403,11 @@ function peg$parse(input, options) {
                   s11 = peg$currPos;
                   s12 = peg$parse_();
                   s13 = input.substr(peg$currPos, 5);
-                  if (s13.toLowerCase() === peg$c29) {
+                  if (s13.toLowerCase() === peg$c33) {
                     peg$currPos += (5);
                   } else {
                     s13 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e33); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e37); }
                   }
                   if (s13 !== peg$FAILED) {
                     s14 = peg$currPos;
@@ -7050,7 +7442,7 @@ function peg$parse(input, options) {
                   s11 = null;
                 }
                 peg$savedPos = s0;
-                s0 = peg$f24(s6, s8, s9, s10, s11);
+                s0 = peg$f25(s6, s8, s9, s10, s11);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -7081,7 +7473,7 @@ function peg$parse(input, options) {
   function peg$parseAlterModifyColumnElement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;
 
-    const key = peg$currPos * 466 + 20;
+    const key = peg$currPos * 508 + 19;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -7098,11 +7490,11 @@ function peg$parse(input, options) {
       s4 = [];
       s5 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 46) {
-        s6 = peg$c35;
+        s6 = peg$c39;
         peg$currPos++;
       } else {
         s6 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s6 !== peg$FAILED) {
         s7 = peg$parseAliasName();
@@ -7122,11 +7514,11 @@ function peg$parse(input, options) {
           s4.push(s5);
           s5 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 46) {
-            s6 = peg$c35;
+            s6 = peg$c39;
             peg$currPos++;
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e39); }
+            if (peg$silentFails === 0) { peg$fail(peg$e43); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$parseAliasName();
@@ -7205,11 +7597,11 @@ function peg$parse(input, options) {
       if (s5 === peg$FAILED) {
         s5 = peg$currPos;
         s6 = input.substr(peg$currPos, 12);
-        if (s6.toLowerCase() === peg$c36) {
+        if (s6.toLowerCase() === peg$c40) {
           peg$currPos += (12);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e40); }
+          if (peg$silentFails === 0) { peg$fail(peg$e44); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -7242,11 +7634,11 @@ function peg$parse(input, options) {
         if (s5 === peg$FAILED) {
           s5 = peg$currPos;
           s6 = input.substr(peg$currPos, 9);
-          if (s6.toLowerCase() === peg$c37) {
+          if (s6.toLowerCase() === peg$c41) {
             peg$currPos += (9);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e41); }
+            if (peg$silentFails === 0) { peg$fail(peg$e45); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$currPos;
@@ -7279,11 +7671,11 @@ function peg$parse(input, options) {
           if (s5 === peg$FAILED) {
             s5 = peg$currPos;
             s6 = input.substr(peg$currPos, 5);
-            if (s6.toLowerCase() === peg$c38) {
+            if (s6.toLowerCase() === peg$c42) {
               peg$currPos += (5);
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e42); }
+              if (peg$silentFails === 0) { peg$fail(peg$e46); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$currPos;
@@ -7316,11 +7708,11 @@ function peg$parse(input, options) {
             if (s5 === peg$FAILED) {
               s5 = peg$currPos;
               s6 = input.substr(peg$currPos, 7);
-              if (s6.toLowerCase() === peg$c39) {
+              if (s6.toLowerCase() === peg$c43) {
                 peg$currPos += (7);
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e43); }
+                if (peg$silentFails === 0) { peg$fail(peg$e47); }
               }
               if (s6 !== peg$FAILED) {
                 s7 = peg$currPos;
@@ -7353,11 +7745,11 @@ function peg$parse(input, options) {
               if (s5 === peg$FAILED) {
                 s5 = peg$currPos;
                 s6 = input.substr(peg$currPos, 5);
-                if (s6.toLowerCase() === peg$c40) {
+                if (s6.toLowerCase() === peg$c44) {
                   peg$currPos += (5);
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e44); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e48); }
                 }
                 if (s6 !== peg$FAILED) {
                   s7 = peg$currPos;
@@ -7390,11 +7782,11 @@ function peg$parse(input, options) {
                 if (s5 === peg$FAILED) {
                   s5 = peg$currPos;
                   s6 = input.substr(peg$currPos, 3);
-                  if (s6.toLowerCase() === peg$c41) {
+                  if (s6.toLowerCase() === peg$c45) {
                     peg$currPos += (3);
                   } else {
                     s6 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e45); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e49); }
                   }
                   if (s6 !== peg$FAILED) {
                     s7 = peg$currPos;
@@ -7427,11 +7819,11 @@ function peg$parse(input, options) {
                   if (s5 === peg$FAILED) {
                     s5 = peg$currPos;
                     s6 = input.substr(peg$currPos, 10);
-                    if (s6.toLowerCase() === peg$c42) {
+                    if (s6.toLowerCase() === peg$c46) {
                       peg$currPos += (10);
                     } else {
                       s6 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e46); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e50); }
                     }
                     if (s6 !== peg$FAILED) {
                       s7 = peg$currPos;
@@ -7464,11 +7856,11 @@ function peg$parse(input, options) {
                     if (s5 === peg$FAILED) {
                       s5 = peg$currPos;
                       s6 = input.substr(peg$currPos, 8);
-                      if (s6.toLowerCase() === peg$c43) {
+                      if (s6.toLowerCase() === peg$c47) {
                         peg$currPos += (8);
                       } else {
                         s6 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e51); }
                       }
                       if (s6 !== peg$FAILED) {
                         s7 = peg$currPos;
@@ -7501,11 +7893,11 @@ function peg$parse(input, options) {
                       if (s5 === peg$FAILED) {
                         s5 = peg$currPos;
                         s6 = input.substr(peg$currPos, 4);
-                        if (s6.toLowerCase() === peg$c44) {
+                        if (s6.toLowerCase() === peg$c48) {
                           peg$currPos += (4);
                         } else {
                           s6 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e52); }
                         }
                         if (s6 !== peg$FAILED) {
                           s7 = peg$currPos;
@@ -7538,11 +7930,11 @@ function peg$parse(input, options) {
                         if (s5 === peg$FAILED) {
                           s5 = peg$currPos;
                           s6 = input.substr(peg$currPos, 3);
-                          if (s6.toLowerCase() === peg$c26) {
+                          if (s6.toLowerCase() === peg$c30) {
                             peg$currPos += (3);
                           } else {
                             s6 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e34); }
                           }
                           if (s6 !== peg$FAILED) {
                             s7 = peg$currPos;
@@ -7564,11 +7956,11 @@ function peg$parse(input, options) {
                             if (s7 !== peg$FAILED) {
                               s8 = peg$parse_();
                               s9 = input.substr(peg$currPos, 4);
-                              if (s9.toLowerCase() === peg$c44) {
+                              if (s9.toLowerCase() === peg$c48) {
                                 peg$currPos += (4);
                               } else {
                                 s9 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                                if (peg$silentFails === 0) { peg$fail(peg$e52); }
                               }
                               if (s9 !== peg$FAILED) {
                                 s10 = peg$currPos;
@@ -7609,11 +8001,11 @@ function peg$parse(input, options) {
                           if (s5 === peg$FAILED) {
                             s5 = peg$currPos;
                             s6 = input.substr(peg$currPos, 6);
-                            if (s6.toLowerCase() === peg$c34) {
+                            if (s6.toLowerCase() === peg$c38) {
                               peg$currPos += (6);
                             } else {
                               s6 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e38); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e42); }
                             }
                             if (s6 !== peg$FAILED) {
                               s7 = peg$currPos;
@@ -7646,11 +8038,11 @@ function peg$parse(input, options) {
                             if (s5 === peg$FAILED) {
                               s5 = peg$currPos;
                               s6 = input.substr(peg$currPos, 6);
-                              if (s6.toLowerCase() === peg$c32) {
+                              if (s6.toLowerCase() === peg$c36) {
                                 peg$currPos += (6);
                               } else {
                                 s6 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e36); }
+                                if (peg$silentFails === 0) { peg$fail(peg$e40); }
                               }
                               if (s6 !== peg$FAILED) {
                                 s7 = peg$currPos;
@@ -7683,11 +8075,11 @@ function peg$parse(input, options) {
                               if (s5 === peg$FAILED) {
                                 s5 = peg$currPos;
                                 s6 = input.substr(peg$currPos, 5);
-                                if (s6.toLowerCase() === peg$c45) {
+                                if (s6.toLowerCase() === peg$c49) {
                                   peg$currPos += (5);
                                 } else {
                                   s6 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e49); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e53); }
                                 }
                                 if (s6 !== peg$FAILED) {
                                   s7 = peg$currPos;
@@ -7720,11 +8112,11 @@ function peg$parse(input, options) {
                                 if (s5 === peg$FAILED) {
                                   s5 = peg$currPos;
                                   s6 = input.substr(peg$currPos, 5);
-                                  if (s6.toLowerCase() === peg$c29) {
+                                  if (s6.toLowerCase() === peg$c33) {
                                     peg$currPos += (5);
                                   } else {
                                     s6 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e33); }
+                                    if (peg$silentFails === 0) { peg$fail(peg$e37); }
                                   }
                                   if (s6 !== peg$FAILED) {
                                     s7 = peg$currPos;
@@ -7757,11 +8149,11 @@ function peg$parse(input, options) {
                                   if (s5 === peg$FAILED) {
                                     s5 = peg$currPos;
                                     s6 = input.substr(peg$currPos, 5);
-                                    if (s6.toLowerCase() === peg$c28) {
+                                    if (s6.toLowerCase() === peg$c32) {
                                       peg$currPos += (5);
                                     } else {
                                       s6 = peg$FAILED;
-                                      if (peg$silentFails === 0) { peg$fail(peg$e32); }
+                                      if (peg$silentFails === 0) { peg$fail(peg$e36); }
                                     }
                                     if (s6 !== peg$FAILED) {
                                       s7 = peg$currPos;
@@ -7797,7 +8189,7 @@ function peg$parse(input, options) {
                                         peg$currPos++;
                                       } else {
                                         s5 = peg$FAILED;
-                                        if (peg$silentFails === 0) { peg$fail(peg$e50); }
+                                        if (peg$silentFails === 0) { peg$fail(peg$e54); }
                                       }
                                     }
                                   }
@@ -7891,7 +8283,7 @@ function peg$parse(input, options) {
         s6 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f25(s1, s2, s3, s4, s5, s6);
+      s0 = peg$f26(s1, s2, s3, s4, s5, s6);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -7943,11 +8335,11 @@ function peg$parse(input, options) {
         if (s5 === peg$FAILED) {
           s5 = peg$currPos;
           s6 = input.substr(peg$currPos, 12);
-          if (s6.toLowerCase() === peg$c36) {
+          if (s6.toLowerCase() === peg$c40) {
             peg$currPos += (12);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e40); }
+            if (peg$silentFails === 0) { peg$fail(peg$e44); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$currPos;
@@ -7980,11 +8372,11 @@ function peg$parse(input, options) {
           if (s5 === peg$FAILED) {
             s5 = peg$currPos;
             s6 = input.substr(peg$currPos, 9);
-            if (s6.toLowerCase() === peg$c37) {
+            if (s6.toLowerCase() === peg$c41) {
               peg$currPos += (9);
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e41); }
+              if (peg$silentFails === 0) { peg$fail(peg$e45); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$currPos;
@@ -8017,11 +8409,11 @@ function peg$parse(input, options) {
             if (s5 === peg$FAILED) {
               s5 = peg$currPos;
               s6 = input.substr(peg$currPos, 5);
-              if (s6.toLowerCase() === peg$c38) {
+              if (s6.toLowerCase() === peg$c42) {
                 peg$currPos += (5);
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e42); }
+                if (peg$silentFails === 0) { peg$fail(peg$e46); }
               }
               if (s6 !== peg$FAILED) {
                 s7 = peg$currPos;
@@ -8054,11 +8446,11 @@ function peg$parse(input, options) {
               if (s5 === peg$FAILED) {
                 s5 = peg$currPos;
                 s6 = input.substr(peg$currPos, 7);
-                if (s6.toLowerCase() === peg$c39) {
+                if (s6.toLowerCase() === peg$c43) {
                   peg$currPos += (7);
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e43); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e47); }
                 }
                 if (s6 !== peg$FAILED) {
                   s7 = peg$currPos;
@@ -8091,11 +8483,11 @@ function peg$parse(input, options) {
                 if (s5 === peg$FAILED) {
                   s5 = peg$currPos;
                   s6 = input.substr(peg$currPos, 5);
-                  if (s6.toLowerCase() === peg$c40) {
+                  if (s6.toLowerCase() === peg$c44) {
                     peg$currPos += (5);
                   } else {
                     s6 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e44); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e48); }
                   }
                   if (s6 !== peg$FAILED) {
                     s7 = peg$currPos;
@@ -8128,11 +8520,11 @@ function peg$parse(input, options) {
                   if (s5 === peg$FAILED) {
                     s5 = peg$currPos;
                     s6 = input.substr(peg$currPos, 3);
-                    if (s6.toLowerCase() === peg$c41) {
+                    if (s6.toLowerCase() === peg$c45) {
                       peg$currPos += (3);
                     } else {
                       s6 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e45); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e49); }
                     }
                     if (s6 !== peg$FAILED) {
                       s7 = peg$currPos;
@@ -8165,11 +8557,11 @@ function peg$parse(input, options) {
                     if (s5 === peg$FAILED) {
                       s5 = peg$currPos;
                       s6 = input.substr(peg$currPos, 10);
-                      if (s6.toLowerCase() === peg$c42) {
+                      if (s6.toLowerCase() === peg$c46) {
                         peg$currPos += (10);
                       } else {
                         s6 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e46); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e50); }
                       }
                       if (s6 !== peg$FAILED) {
                         s7 = peg$currPos;
@@ -8202,11 +8594,11 @@ function peg$parse(input, options) {
                       if (s5 === peg$FAILED) {
                         s5 = peg$currPos;
                         s6 = input.substr(peg$currPos, 8);
-                        if (s6.toLowerCase() === peg$c43) {
+                        if (s6.toLowerCase() === peg$c47) {
                           peg$currPos += (8);
                         } else {
                           s6 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e51); }
                         }
                         if (s6 !== peg$FAILED) {
                           s7 = peg$currPos;
@@ -8239,11 +8631,11 @@ function peg$parse(input, options) {
                         if (s5 === peg$FAILED) {
                           s5 = peg$currPos;
                           s6 = input.substr(peg$currPos, 4);
-                          if (s6.toLowerCase() === peg$c44) {
+                          if (s6.toLowerCase() === peg$c48) {
                             peg$currPos += (4);
                           } else {
                             s6 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e52); }
                           }
                           if (s6 !== peg$FAILED) {
                             s7 = peg$currPos;
@@ -8276,11 +8668,11 @@ function peg$parse(input, options) {
                           if (s5 === peg$FAILED) {
                             s5 = peg$currPos;
                             s6 = input.substr(peg$currPos, 3);
-                            if (s6.toLowerCase() === peg$c26) {
+                            if (s6.toLowerCase() === peg$c30) {
                               peg$currPos += (3);
                             } else {
                               s6 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e34); }
                             }
                             if (s6 !== peg$FAILED) {
                               s7 = peg$currPos;
@@ -8302,11 +8694,11 @@ function peg$parse(input, options) {
                               if (s7 !== peg$FAILED) {
                                 s8 = peg$parse_();
                                 s9 = input.substr(peg$currPos, 4);
-                                if (s9.toLowerCase() === peg$c44) {
+                                if (s9.toLowerCase() === peg$c48) {
                                   peg$currPos += (4);
                                 } else {
                                   s9 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e52); }
                                 }
                                 if (s9 !== peg$FAILED) {
                                   s10 = peg$currPos;
@@ -8347,11 +8739,11 @@ function peg$parse(input, options) {
                             if (s5 === peg$FAILED) {
                               s5 = peg$currPos;
                               s6 = input.substr(peg$currPos, 14);
-                              if (s6.toLowerCase() === peg$c46) {
+                              if (s6.toLowerCase() === peg$c50) {
                                 peg$currPos += (14);
                               } else {
                                 s6 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e51); }
+                                if (peg$silentFails === 0) { peg$fail(peg$e55); }
                               }
                               if (s6 !== peg$FAILED) {
                                 s7 = peg$currPos;
@@ -8384,11 +8776,11 @@ function peg$parse(input, options) {
                               if (s5 === peg$FAILED) {
                                 s5 = peg$currPos;
                                 s6 = input.substr(peg$currPos, 7);
-                                if (s6.toLowerCase() === peg$c47) {
+                                if (s6.toLowerCase() === peg$c51) {
                                   peg$currPos += (7);
                                 } else {
                                   s6 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e52); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e56); }
                                 }
                                 if (s6 !== peg$FAILED) {
                                   s7 = peg$currPos;
@@ -8421,11 +8813,11 @@ function peg$parse(input, options) {
                                 if (s5 === peg$FAILED) {
                                   s5 = peg$currPos;
                                   s6 = input.substr(peg$currPos, 7);
-                                  if (s6.toLowerCase() === peg$c48) {
+                                  if (s6.toLowerCase() === peg$c52) {
                                     peg$currPos += (7);
                                   } else {
                                     s6 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e53); }
+                                    if (peg$silentFails === 0) { peg$fail(peg$e57); }
                                   }
                                   if (s6 !== peg$FAILED) {
                                     s7 = peg$currPos;
@@ -8458,11 +8850,11 @@ function peg$parse(input, options) {
                                   if (s5 === peg$FAILED) {
                                     s5 = peg$currPos;
                                     s6 = input.substr(peg$currPos, 6);
-                                    if (s6.toLowerCase() === peg$c34) {
+                                    if (s6.toLowerCase() === peg$c38) {
                                       peg$currPos += (6);
                                     } else {
                                       s6 = peg$FAILED;
-                                      if (peg$silentFails === 0) { peg$fail(peg$e38); }
+                                      if (peg$silentFails === 0) { peg$fail(peg$e42); }
                                     }
                                     if (s6 !== peg$FAILED) {
                                       s7 = peg$currPos;
@@ -8495,11 +8887,11 @@ function peg$parse(input, options) {
                                     if (s5 === peg$FAILED) {
                                       s5 = peg$currPos;
                                       s6 = input.substr(peg$currPos, 6);
-                                      if (s6.toLowerCase() === peg$c32) {
+                                      if (s6.toLowerCase() === peg$c36) {
                                         peg$currPos += (6);
                                       } else {
                                         s6 = peg$FAILED;
-                                        if (peg$silentFails === 0) { peg$fail(peg$e36); }
+                                        if (peg$silentFails === 0) { peg$fail(peg$e40); }
                                       }
                                       if (s6 !== peg$FAILED) {
                                         s7 = peg$currPos;
@@ -8532,11 +8924,11 @@ function peg$parse(input, options) {
                                       if (s5 === peg$FAILED) {
                                         s5 = peg$currPos;
                                         s6 = input.substr(peg$currPos, 5);
-                                        if (s6.toLowerCase() === peg$c45) {
+                                        if (s6.toLowerCase() === peg$c49) {
                                           peg$currPos += (5);
                                         } else {
                                           s6 = peg$FAILED;
-                                          if (peg$silentFails === 0) { peg$fail(peg$e49); }
+                                          if (peg$silentFails === 0) { peg$fail(peg$e53); }
                                         }
                                         if (s6 !== peg$FAILED) {
                                           s7 = peg$currPos;
@@ -8569,11 +8961,11 @@ function peg$parse(input, options) {
                                         if (s5 === peg$FAILED) {
                                           s5 = peg$currPos;
                                           s6 = input.substr(peg$currPos, 5);
-                                          if (s6.toLowerCase() === peg$c29) {
+                                          if (s6.toLowerCase() === peg$c33) {
                                             peg$currPos += (5);
                                           } else {
                                             s6 = peg$FAILED;
-                                            if (peg$silentFails === 0) { peg$fail(peg$e33); }
+                                            if (peg$silentFails === 0) { peg$fail(peg$e37); }
                                           }
                                           if (s6 !== peg$FAILED) {
                                             s7 = peg$currPos;
@@ -8606,11 +8998,11 @@ function peg$parse(input, options) {
                                           if (s5 === peg$FAILED) {
                                             s5 = peg$currPos;
                                             s6 = input.substr(peg$currPos, 5);
-                                            if (s6.toLowerCase() === peg$c28) {
+                                            if (s6.toLowerCase() === peg$c32) {
                                               peg$currPos += (5);
                                             } else {
                                               s6 = peg$FAILED;
-                                              if (peg$silentFails === 0) { peg$fail(peg$e32); }
+                                              if (peg$silentFails === 0) { peg$fail(peg$e36); }
                                             }
                                             if (s6 !== peg$FAILED) {
                                               s7 = peg$currPos;
@@ -8646,7 +9038,7 @@ function peg$parse(input, options) {
                                                 peg$currPos++;
                                               } else {
                                                 s5 = peg$FAILED;
-                                                if (peg$silentFails === 0) { peg$fail(peg$e50); }
+                                                if (peg$silentFails === 0) { peg$fail(peg$e54); }
                                               }
                                             }
                                           }
@@ -8693,11 +9085,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 7);
-        if (s5.toLowerCase() === peg$c47) {
+        if (s5.toLowerCase() === peg$c51) {
           peg$currPos += (7);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e52); }
+          if (peg$silentFails === 0) { peg$fail(peg$e56); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -8753,11 +9145,11 @@ function peg$parse(input, options) {
         s5 = peg$currPos;
         s6 = peg$parse_();
         s7 = input.substr(peg$currPos, 14);
-        if (s7.toLowerCase() === peg$c46) {
+        if (s7.toLowerCase() === peg$c50) {
           peg$currPos += (14);
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e51); }
+          if (peg$silentFails === 0) { peg$fail(peg$e55); }
         }
         if (s7 !== peg$FAILED) {
           s8 = peg$currPos;
@@ -8793,11 +9185,11 @@ function peg$parse(input, options) {
         s6 = peg$currPos;
         s7 = peg$parse_();
         s8 = input.substr(peg$currPos, 7);
-        if (s8.toLowerCase() === peg$c48) {
+        if (s8.toLowerCase() === peg$c52) {
           peg$currPos += (7);
         } else {
           s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e53); }
+          if (peg$silentFails === 0) { peg$fail(peg$e57); }
         }
         if (s8 !== peg$FAILED) {
           s9 = peg$currPos;
@@ -8819,11 +9211,11 @@ function peg$parse(input, options) {
           if (s9 !== peg$FAILED) {
             s10 = peg$parse_();
             s11 = input.substr(peg$currPos, 3);
-            if (s11.toLowerCase() === peg$c49) {
+            if (s11.toLowerCase() === peg$c53) {
               peg$currPos += (3);
             } else {
               s11 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e54); }
+              if (peg$silentFails === 0) { peg$fail(peg$e58); }
             }
             if (s11 !== peg$FAILED) {
               s12 = peg$currPos;
@@ -8956,7 +9348,7 @@ function peg$parse(input, options) {
           s13 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f26(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13);
+        s0 = peg$f27(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -8971,7 +9363,7 @@ function peg$parse(input, options) {
   function peg$parseAlterRemoveProperty() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 21;
+    const key = peg$currPos * 508 + 20;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -9007,7 +9399,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f27();
+        s0 = peg$f28();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -9019,11 +9411,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 12);
-      if (s1.toLowerCase() === peg$c36) {
+      if (s1.toLowerCase() === peg$c40) {
         peg$currPos += (12);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e40); }
+        if (peg$silentFails === 0) { peg$fail(peg$e44); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -9044,7 +9436,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f28();
+          s0 = peg$f29();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -9056,11 +9448,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 5);
-        if (s1.toLowerCase() === peg$c38) {
+        if (s1.toLowerCase() === peg$c42) {
           peg$currPos += (5);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e42); }
+          if (peg$silentFails === 0) { peg$fail(peg$e46); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -9081,7 +9473,7 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f29();
+            s0 = peg$f30();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -9093,11 +9485,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 7);
-          if (s1.toLowerCase() === peg$c39) {
+          if (s1.toLowerCase() === peg$c43) {
             peg$currPos += (7);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e43); }
+            if (peg$silentFails === 0) { peg$fail(peg$e47); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -9118,7 +9510,7 @@ function peg$parse(input, options) {
             }
             if (s2 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f30();
+              s0 = peg$f31();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -9130,11 +9522,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 5);
-            if (s1.toLowerCase() === peg$c40) {
+            if (s1.toLowerCase() === peg$c44) {
               peg$currPos += (5);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e44); }
+              if (peg$silentFails === 0) { peg$fail(peg$e48); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -9155,7 +9547,7 @@ function peg$parse(input, options) {
               }
               if (s2 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f31();
+                s0 = peg$f32();
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -9167,11 +9559,11 @@ function peg$parse(input, options) {
             if (s0 === peg$FAILED) {
               s0 = peg$currPos;
               s1 = input.substr(peg$currPos, 3);
-              if (s1.toLowerCase() === peg$c41) {
+              if (s1.toLowerCase() === peg$c45) {
                 peg$currPos += (3);
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e45); }
+                if (peg$silentFails === 0) { peg$fail(peg$e49); }
               }
               if (s1 !== peg$FAILED) {
                 s2 = peg$currPos;
@@ -9192,7 +9584,7 @@ function peg$parse(input, options) {
                 }
                 if (s2 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f32();
+                  s0 = peg$f33();
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -9204,11 +9596,11 @@ function peg$parse(input, options) {
               if (s0 === peg$FAILED) {
                 s0 = peg$currPos;
                 s1 = input.substr(peg$currPos, 8);
-                if (s1.toLowerCase() === peg$c43) {
+                if (s1.toLowerCase() === peg$c47) {
                   peg$currPos += (8);
                 } else {
                   s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e51); }
                 }
                 if (s1 !== peg$FAILED) {
                   s2 = peg$currPos;
@@ -9229,7 +9621,7 @@ function peg$parse(input, options) {
                   }
                   if (s2 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f33();
+                    s0 = peg$f34();
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -9253,7 +9645,7 @@ function peg$parse(input, options) {
   function peg$parseAlterModifyColumnSettingClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 22;
+    const key = peg$currPos * 508 + 21;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -9264,11 +9656,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c32) {
+    if (s1.toLowerCase() === peg$c36) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e36); }
+      if (peg$silentFails === 0) { peg$fail(peg$e40); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -9290,11 +9682,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 7);
-        if (s4.toLowerCase() === peg$c50) {
+        if (s4.toLowerCase() === peg$c54) {
           peg$currPos += (7);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e55); }
+          if (peg$silentFails === 0) { peg$fail(peg$e59); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -9318,7 +9710,7 @@ function peg$parse(input, options) {
             s7 = peg$parseSettingsList();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f34(s7);
+              s0 = peg$f35(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -9342,11 +9734,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c45) {
+      if (s1.toLowerCase() === peg$c49) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e49); }
+        if (peg$silentFails === 0) { peg$fail(peg$e53); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -9368,11 +9760,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 7);
-          if (s4.toLowerCase() === peg$c50) {
+          if (s4.toLowerCase() === peg$c54) {
             peg$currPos += (7);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e55); }
+            if (peg$silentFails === 0) { peg$fail(peg$e59); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -9393,10 +9785,10 @@ function peg$parse(input, options) {
             }
             if (s5 !== peg$FAILED) {
               s6 = peg$parse_();
-              s7 = peg$parseAlterResetSettingNames();
+              s7 = peg$parseAliasNameList();
               if (s7 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f35(s7);
+                s0 = peg$f36(s7);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -9427,7 +9819,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandRenameColumn() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 23;
+    const key = peg$currPos * 508 + 22;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -9438,11 +9830,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c51) {
+    if (s1.toLowerCase() === peg$c55) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e56); }
+      if (peg$silentFails === 0) { peg$fail(peg$e60); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -9464,11 +9856,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c24) {
+        if (s4.toLowerCase() === peg$c28) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+          if (peg$silentFails === 0) { peg$fail(peg$e32); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -9491,11 +9883,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -9517,11 +9909,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -9595,7 +9987,7 @@ function peg$parse(input, options) {
                   s13 = peg$parseAlterColumnRef();
                   if (s13 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f36(s6, s8, s13);
+                    s0 = peg$f37(s6, s8, s13);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -9637,7 +10029,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandCommentColumn() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 24;
+    const key = peg$currPos * 508 + 23;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -9648,11 +10040,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c39) {
+    if (s1.toLowerCase() === peg$c43) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e43); }
+      if (peg$silentFails === 0) { peg$fail(peg$e47); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -9674,11 +10066,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c24) {
+        if (s4.toLowerCase() === peg$c28) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+          if (peg$silentFails === 0) { peg$fail(peg$e32); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -9701,11 +10093,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -9727,11 +10119,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -9779,7 +10171,7 @@ function peg$parse(input, options) {
               s10 = peg$parseStringLiteral();
               if (s10 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f37(s6, s8, s10);
+                s0 = peg$f38(s6, s8, s10);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -9813,7 +10205,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandMaterializeColumn() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 25;
+    const key = peg$currPos * 508 + 24;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -9824,11 +10216,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 11);
-    if (s1.toLowerCase() === peg$c52) {
+    if (s1.toLowerCase() === peg$c56) {
       peg$currPos += (11);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e57); }
+      if (peg$silentFails === 0) { peg$fail(peg$e61); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -9850,11 +10242,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c24) {
+        if (s4.toLowerCase() === peg$c28) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+          if (peg$silentFails === 0) { peg$fail(peg$e32); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -9877,11 +10269,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -9903,11 +10295,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -9965,7 +10357,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f38(s6, s8, s9);
+              s0 = peg$f39(s6, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -9995,7 +10387,7 @@ function peg$parse(input, options) {
   function peg$parseAlterColumnElement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 26;
+    const key = peg$currPos * 508 + 25;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -10012,11 +10404,11 @@ function peg$parse(input, options) {
       s4 = [];
       s5 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 46) {
-        s6 = peg$c35;
+        s6 = peg$c39;
         peg$currPos++;
       } else {
         s6 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s6 !== peg$FAILED) {
         s7 = peg$parseAliasName();
@@ -10036,11 +10428,11 @@ function peg$parse(input, options) {
           s4.push(s5);
           s5 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 46) {
-            s6 = peg$c35;
+            s6 = peg$c39;
             peg$currPos++;
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e39); }
+            if (peg$silentFails === 0) { peg$fail(peg$e43); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$parseAliasName();
@@ -10119,11 +10511,11 @@ function peg$parse(input, options) {
       if (s5 === peg$FAILED) {
         s5 = peg$currPos;
         s6 = input.substr(peg$currPos, 12);
-        if (s6.toLowerCase() === peg$c36) {
+        if (s6.toLowerCase() === peg$c40) {
           peg$currPos += (12);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e40); }
+          if (peg$silentFails === 0) { peg$fail(peg$e44); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -10156,11 +10548,11 @@ function peg$parse(input, options) {
         if (s5 === peg$FAILED) {
           s5 = peg$currPos;
           s6 = input.substr(peg$currPos, 9);
-          if (s6.toLowerCase() === peg$c37) {
+          if (s6.toLowerCase() === peg$c41) {
             peg$currPos += (9);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e41); }
+            if (peg$silentFails === 0) { peg$fail(peg$e45); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$currPos;
@@ -10193,11 +10585,11 @@ function peg$parse(input, options) {
           if (s5 === peg$FAILED) {
             s5 = peg$currPos;
             s6 = input.substr(peg$currPos, 5);
-            if (s6.toLowerCase() === peg$c38) {
+            if (s6.toLowerCase() === peg$c42) {
               peg$currPos += (5);
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e42); }
+              if (peg$silentFails === 0) { peg$fail(peg$e46); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$currPos;
@@ -10230,11 +10622,11 @@ function peg$parse(input, options) {
             if (s5 === peg$FAILED) {
               s5 = peg$currPos;
               s6 = input.substr(peg$currPos, 7);
-              if (s6.toLowerCase() === peg$c39) {
+              if (s6.toLowerCase() === peg$c43) {
                 peg$currPos += (7);
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e43); }
+                if (peg$silentFails === 0) { peg$fail(peg$e47); }
               }
               if (s6 !== peg$FAILED) {
                 s7 = peg$currPos;
@@ -10267,11 +10659,11 @@ function peg$parse(input, options) {
               if (s5 === peg$FAILED) {
                 s5 = peg$currPos;
                 s6 = input.substr(peg$currPos, 5);
-                if (s6.toLowerCase() === peg$c40) {
+                if (s6.toLowerCase() === peg$c44) {
                   peg$currPos += (5);
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e44); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e48); }
                 }
                 if (s6 !== peg$FAILED) {
                   s7 = peg$currPos;
@@ -10304,11 +10696,11 @@ function peg$parse(input, options) {
                 if (s5 === peg$FAILED) {
                   s5 = peg$currPos;
                   s6 = input.substr(peg$currPos, 3);
-                  if (s6.toLowerCase() === peg$c41) {
+                  if (s6.toLowerCase() === peg$c45) {
                     peg$currPos += (3);
                   } else {
                     s6 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e45); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e49); }
                   }
                   if (s6 !== peg$FAILED) {
                     s7 = peg$currPos;
@@ -10341,11 +10733,11 @@ function peg$parse(input, options) {
                   if (s5 === peg$FAILED) {
                     s5 = peg$currPos;
                     s6 = input.substr(peg$currPos, 10);
-                    if (s6.toLowerCase() === peg$c42) {
+                    if (s6.toLowerCase() === peg$c46) {
                       peg$currPos += (10);
                     } else {
                       s6 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e46); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e50); }
                     }
                     if (s6 !== peg$FAILED) {
                       s7 = peg$currPos;
@@ -10378,11 +10770,11 @@ function peg$parse(input, options) {
                     if (s5 === peg$FAILED) {
                       s5 = peg$currPos;
                       s6 = input.substr(peg$currPos, 8);
-                      if (s6.toLowerCase() === peg$c43) {
+                      if (s6.toLowerCase() === peg$c47) {
                         peg$currPos += (8);
                       } else {
                         s6 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e51); }
                       }
                       if (s6 !== peg$FAILED) {
                         s7 = peg$currPos;
@@ -10415,11 +10807,11 @@ function peg$parse(input, options) {
                       if (s5 === peg$FAILED) {
                         s5 = peg$currPos;
                         s6 = input.substr(peg$currPos, 4);
-                        if (s6.toLowerCase() === peg$c44) {
+                        if (s6.toLowerCase() === peg$c48) {
                           peg$currPos += (4);
                         } else {
                           s6 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e52); }
                         }
                         if (s6 !== peg$FAILED) {
                           s7 = peg$currPos;
@@ -10452,11 +10844,11 @@ function peg$parse(input, options) {
                         if (s5 === peg$FAILED) {
                           s5 = peg$currPos;
                           s6 = input.substr(peg$currPos, 3);
-                          if (s6.toLowerCase() === peg$c26) {
+                          if (s6.toLowerCase() === peg$c30) {
                             peg$currPos += (3);
                           } else {
                             s6 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e34); }
                           }
                           if (s6 !== peg$FAILED) {
                             s7 = peg$currPos;
@@ -10478,11 +10870,11 @@ function peg$parse(input, options) {
                             if (s7 !== peg$FAILED) {
                               s8 = peg$parse_();
                               s9 = input.substr(peg$currPos, 4);
-                              if (s9.toLowerCase() === peg$c44) {
+                              if (s9.toLowerCase() === peg$c48) {
                                 peg$currPos += (4);
                               } else {
                                 s9 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                                if (peg$silentFails === 0) { peg$fail(peg$e52); }
                               }
                               if (s9 !== peg$FAILED) {
                                 s10 = peg$currPos;
@@ -10523,11 +10915,11 @@ function peg$parse(input, options) {
                           if (s5 === peg$FAILED) {
                             s5 = peg$currPos;
                             s6 = input.substr(peg$currPos, 14);
-                            if (s6.toLowerCase() === peg$c46) {
+                            if (s6.toLowerCase() === peg$c50) {
                               peg$currPos += (14);
                             } else {
                               s6 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e51); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e55); }
                             }
                             if (s6 !== peg$FAILED) {
                               s7 = peg$currPos;
@@ -10560,11 +10952,11 @@ function peg$parse(input, options) {
                             if (s5 === peg$FAILED) {
                               s5 = peg$currPos;
                               s6 = input.substr(peg$currPos, 7);
-                              if (s6.toLowerCase() === peg$c47) {
+                              if (s6.toLowerCase() === peg$c51) {
                                 peg$currPos += (7);
                               } else {
                                 s6 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e52); }
+                                if (peg$silentFails === 0) { peg$fail(peg$e56); }
                               }
                               if (s6 !== peg$FAILED) {
                                 s7 = peg$currPos;
@@ -10597,11 +10989,11 @@ function peg$parse(input, options) {
                               if (s5 === peg$FAILED) {
                                 s5 = peg$currPos;
                                 s6 = input.substr(peg$currPos, 7);
-                                if (s6.toLowerCase() === peg$c48) {
+                                if (s6.toLowerCase() === peg$c52) {
                                   peg$currPos += (7);
                                 } else {
                                   s6 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e53); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e57); }
                                 }
                                 if (s6 !== peg$FAILED) {
                                   s7 = peg$currPos;
@@ -10637,7 +11029,7 @@ function peg$parse(input, options) {
                                     peg$currPos++;
                                   } else {
                                     s5 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e50); }
+                                    if (peg$silentFails === 0) { peg$fail(peg$e54); }
                                   }
                                 }
                               }
@@ -10729,7 +11121,7 @@ function peg$parse(input, options) {
         s6 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f39(s1, s2, s3, s4, s5, s6);
+      s0 = peg$f40(s1, s2, s3, s4, s5, s6);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -10746,7 +11138,7 @@ function peg$parse(input, options) {
   function peg$parseAlterProjectionDef() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20;
 
-    const key = peg$currPos * 466 + 27;
+    const key = peg$currPos * 508 + 26;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -10760,11 +11152,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s3 = peg$c21;
+        s3 = peg$c25;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -10772,21 +11164,21 @@ function peg$parse(input, options) {
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 41) {
-            s7 = peg$c22;
+            s7 = peg$c26;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e26); }
+            if (peg$silentFails === 0) { peg$fail(peg$e30); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$currPos;
             s9 = peg$parse_();
             s10 = input.substr(peg$currPos, 4);
-            if (s10.toLowerCase() === peg$c53) {
+            if (s10.toLowerCase() === peg$c57) {
               peg$currPos += (4);
             } else {
               s10 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e58); }
+              if (peg$silentFails === 0) { peg$fail(peg$e62); }
             }
             if (s10 !== peg$FAILED) {
               s11 = peg$currPos;
@@ -10808,11 +11200,11 @@ function peg$parse(input, options) {
               if (s11 !== peg$FAILED) {
                 s12 = peg$parse_();
                 s13 = input.substr(peg$currPos, 8);
-                if (s13.toLowerCase() === peg$c43) {
+                if (s13.toLowerCase() === peg$c47) {
                   peg$currPos += (8);
                 } else {
                   s13 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e51); }
                 }
                 if (s13 !== peg$FAILED) {
                   s14 = peg$currPos;
@@ -10834,11 +11226,11 @@ function peg$parse(input, options) {
                   if (s14 !== peg$FAILED) {
                     s15 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 40) {
-                      s16 = peg$c21;
+                      s16 = peg$c25;
                       peg$currPos++;
                     } else {
                       s16 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e29); }
                     }
                     if (s16 !== peg$FAILED) {
                       s17 = peg$parse_();
@@ -10846,11 +11238,11 @@ function peg$parse(input, options) {
                       if (s18 !== peg$FAILED) {
                         s19 = peg$parse_();
                         if (input.charCodeAt(peg$currPos) === 41) {
-                          s20 = peg$c22;
+                          s20 = peg$c26;
                           peg$currPos++;
                         } else {
                           s20 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e30); }
                         }
                         if (s20 !== peg$FAILED) {
                           s9 = [s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20];
@@ -10887,7 +11279,7 @@ function peg$parse(input, options) {
               s8 = null;
             }
             peg$savedPos = s0;
-            s0 = peg$f40(s1, s5, s8);
+            s0 = peg$f41(s1, s5, s8);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -10910,11 +11302,11 @@ function peg$parse(input, options) {
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         s3 = input.substr(peg$currPos, 5);
-        if (s3.toLowerCase() === peg$c54) {
+        if (s3.toLowerCase() === peg$c58) {
           peg$currPos += (5);
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e59); }
+          if (peg$silentFails === 0) { peg$fail(peg$e63); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$currPos;
@@ -10939,11 +11331,11 @@ function peg$parse(input, options) {
             if (s6 !== peg$FAILED) {
               s7 = peg$parse_();
               s8 = input.substr(peg$currPos, 4);
-              if (s8.toLowerCase() === peg$c33) {
+              if (s8.toLowerCase() === peg$c37) {
                 peg$currPos += (4);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e37); }
+                if (peg$silentFails === 0) { peg$fail(peg$e41); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -10967,7 +11359,7 @@ function peg$parse(input, options) {
                   s11 = peg$parseIndexTypeSpec();
                   if (s11 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f41(s1, s6, s11);
+                    s0 = peg$f42(s1, s6, s11);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -11006,7 +11398,7 @@ function peg$parse(input, options) {
   function peg$parseAlterConstraintDef() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 28;
+    const key = peg$currPos * 508 + 27;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -11020,19 +11412,19 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       s3 = input.substr(peg$currPos, 5);
-      if (s3.toLowerCase() === peg$c55) {
+      if (s3.toLowerCase() === peg$c59) {
         peg$currPos += (5);
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e60); }
+        if (peg$silentFails === 0) { peg$fail(peg$e64); }
       }
       if (s3 === peg$FAILED) {
         s3 = input.substr(peg$currPos, 6);
-        if (s3.toLowerCase() === peg$c56) {
+        if (s3.toLowerCase() === peg$c60) {
           peg$currPos += (6);
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e61); }
+          if (peg$silentFails === 0) { peg$fail(peg$e65); }
         }
       }
       if (s3 !== peg$FAILED) {
@@ -11057,7 +11449,7 @@ function peg$parse(input, options) {
           s6 = peg$parseExpression();
           if (s6 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f42(s1, s3, s6);
+            s0 = peg$f43(s1, s3, s6);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -11083,7 +11475,7 @@ function peg$parse(input, options) {
   function peg$parseAlterIndexDef() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 29;
+    const key = peg$currPos * 508 + 28;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -11100,11 +11492,11 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 4);
-        if (s5.toLowerCase() === peg$c33) {
+        if (s5.toLowerCase() === peg$c37) {
           peg$currPos += (4);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e37); }
+          if (peg$silentFails === 0) { peg$fail(peg$e41); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -11130,11 +11522,11 @@ function peg$parse(input, options) {
               s9 = peg$currPos;
               s10 = peg$parse_();
               s11 = input.substr(peg$currPos, 11);
-              if (s11.toLowerCase() === peg$c57) {
+              if (s11.toLowerCase() === peg$c61) {
                 peg$currPos += (11);
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e62); }
+                if (peg$silentFails === 0) { peg$fail(peg$e66); }
               }
               if (s11 !== peg$FAILED) {
                 s12 = peg$currPos;
@@ -11185,7 +11577,7 @@ function peg$parse(input, options) {
                   }
                   if (s14 !== peg$FAILED) {
                     peg$savedPos = s9;
-                    s9 = peg$f43(s1, s3, s8, s14);
+                    s9 = peg$f44(s1, s3, s8, s14);
                   } else {
                     peg$currPos = s9;
                     s9 = peg$FAILED;
@@ -11202,7 +11594,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f44(s1, s3, s8, s9);
+              s0 = peg$f45(s1, s3, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -11232,7 +11624,7 @@ function peg$parse(input, options) {
   function peg$parseAlterColumnRef() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 30;
+    const key = peg$currPos * 508 + 29;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -11247,11 +11639,11 @@ function peg$parse(input, options) {
       s2 = [];
       s3 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 46) {
-        s4 = peg$c35;
+        s4 = peg$c39;
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s4 !== peg$FAILED) {
         s5 = peg$parseAliasName();
@@ -11270,11 +11662,11 @@ function peg$parse(input, options) {
         s2.push(s3);
         s3 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 46) {
-          s4 = peg$c35;
+          s4 = peg$c39;
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e39); }
+          if (peg$silentFails === 0) { peg$fail(peg$e43); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$parseAliasName();
@@ -11291,7 +11683,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f45(s1, s2);
+      s0 = peg$f46(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -11305,7 +11697,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandAddIndex() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 31;
+    const key = peg$currPos * 508 + 30;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -11316,11 +11708,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c23) {
+    if (s1.toLowerCase() === peg$c27) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e27); }
+      if (peg$silentFails === 0) { peg$fail(peg$e31); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -11342,11 +11734,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c54) {
+        if (s4.toLowerCase() === peg$c58) {
           peg$currPos += (5);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e59); }
+          if (peg$silentFails === 0) { peg$fail(peg$e63); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -11369,11 +11761,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -11395,11 +11787,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 3);
-                if (s11.toLowerCase() === peg$c26) {
+                if (s11.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -11421,11 +11813,11 @@ function peg$parse(input, options) {
                   if (s12 !== peg$FAILED) {
                     s13 = peg$parse_();
                     s14 = input.substr(peg$currPos, 6);
-                    if (s14.toLowerCase() === peg$c27) {
+                    if (s14.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s14 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s14 !== peg$FAILED) {
                       s15 = peg$currPos;
@@ -11480,11 +11872,11 @@ function peg$parse(input, options) {
               s9 = peg$currPos;
               s10 = peg$parse_();
               s11 = input.substr(peg$currPos, 5);
-              if (s11.toLowerCase() === peg$c28) {
+              if (s11.toLowerCase() === peg$c32) {
                 peg$currPos += (5);
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e32); }
+                if (peg$silentFails === 0) { peg$fail(peg$e36); }
               }
               if (s11 !== peg$FAILED) {
                 s12 = peg$currPos;
@@ -11525,11 +11917,11 @@ function peg$parse(input, options) {
                 s9 = peg$currPos;
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 5);
-                if (s11.toLowerCase() === peg$c29) {
+                if (s11.toLowerCase() === peg$c33) {
                   peg$currPos += (5);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e33); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e37); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -11564,188 +11956,6 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f46(s6, s8, s9);
-            } else {
-              peg$currPos = s0;
-              s0 = peg$FAILED;
-            }
-          } else {
-            peg$currPos = s0;
-            s0 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
-
-    return s0;
-  }
-
-  function peg$parseAlterCommandDropIndex() {
-    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
-
-    const key = peg$currPos * 466 + 32;
-    const cached = peg$resultsCache[key];
-
-    if (cached) {
-      peg$currPos = cached.nextPos;
-
-      return cached.result;
-    }
-
-    s0 = peg$currPos;
-    s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c30) {
-      peg$currPos += (4);
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e34); }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = peg$currPos;
-      peg$silentFails++;
-      s3 = input.charAt(peg$currPos);
-      if (peg$r0.test(s3)) {
-        peg$currPos++;
-      } else {
-        s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e2); }
-      }
-      peg$silentFails--;
-      if (s3 === peg$FAILED) {
-        s2 = undefined;
-      } else {
-        peg$currPos = s2;
-        s2 = peg$FAILED;
-      }
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parse_();
-        s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c54) {
-          peg$currPos += (5);
-        } else {
-          s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e59); }
-        }
-        if (s4 !== peg$FAILED) {
-          s5 = peg$currPos;
-          peg$silentFails++;
-          s6 = input.charAt(peg$currPos);
-          if (peg$r0.test(s6)) {
-            peg$currPos++;
-          } else {
-            s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e2); }
-          }
-          peg$silentFails--;
-          if (s6 === peg$FAILED) {
-            s5 = undefined;
-          } else {
-            peg$currPos = s5;
-            s5 = peg$FAILED;
-          }
-          if (s5 !== peg$FAILED) {
-            s6 = peg$currPos;
-            s7 = peg$parse_();
-            s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
-              peg$currPos += (2);
-            } else {
-              s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
-            }
-            if (s8 !== peg$FAILED) {
-              s9 = peg$currPos;
-              peg$silentFails++;
-              s10 = input.charAt(peg$currPos);
-              if (peg$r0.test(s10)) {
-                peg$currPos++;
-              } else {
-                s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e2); }
-              }
-              peg$silentFails--;
-              if (s10 === peg$FAILED) {
-                s9 = undefined;
-              } else {
-                peg$currPos = s9;
-                s9 = peg$FAILED;
-              }
-              if (s9 !== peg$FAILED) {
-                s10 = peg$parse_();
-                s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
-                  peg$currPos += (6);
-                } else {
-                  s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
-                }
-                if (s11 !== peg$FAILED) {
-                  s12 = peg$currPos;
-                  peg$silentFails++;
-                  s13 = input.charAt(peg$currPos);
-                  if (peg$r0.test(s13)) {
-                    peg$currPos++;
-                  } else {
-                    s13 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
-                  }
-                  peg$silentFails--;
-                  if (s13 === peg$FAILED) {
-                    s12 = undefined;
-                  } else {
-                    peg$currPos = s12;
-                    s12 = peg$FAILED;
-                  }
-                  if (s12 !== peg$FAILED) {
-                    s7 = [s7, s8, s9, s10, s11, s12];
-                    s6 = s7;
-                  } else {
-                    peg$currPos = s6;
-                    s6 = peg$FAILED;
-                  }
-                } else {
-                  peg$currPos = s6;
-                  s6 = peg$FAILED;
-                }
-              } else {
-                peg$currPos = s6;
-                s6 = peg$FAILED;
-              }
-            } else {
-              peg$currPos = s6;
-              s6 = peg$FAILED;
-            }
-            if (s6 === peg$FAILED) {
-              s6 = null;
-            }
-            s7 = peg$parse_();
-            s8 = peg$parseAliasName();
-            if (s8 !== peg$FAILED) {
-              s9 = peg$currPos;
-              s10 = peg$parse_();
-              s11 = peg$parseAlterInPartitionClause();
-              if (s11 !== peg$FAILED) {
-                s10 = [s10, s11];
-                s9 = s10;
-              } else {
-                peg$currPos = s9;
-                s9 = peg$FAILED;
-              }
-              if (s9 === peg$FAILED) {
-                s9 = null;
-              }
-              peg$savedPos = s0;
               s0 = peg$f47(s6, s8, s9);
             } else {
               peg$currPos = s0;
@@ -11773,10 +11983,192 @@ function peg$parse(input, options) {
     return s0;
   }
 
+  function peg$parseAlterCommandDropIndex() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
+
+    const key = peg$currPos * 508 + 31;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 4);
+    if (s1.toLowerCase() === peg$c34) {
+      peg$currPos += (4);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e38); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = input.substr(peg$currPos, 5);
+        if (s4.toLowerCase() === peg$c58) {
+          peg$currPos += (5);
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e63); }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          peg$silentFails++;
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s6 === peg$FAILED) {
+            s5 = undefined;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = peg$currPos;
+            s7 = peg$parse_();
+            s8 = input.substr(peg$currPos, 2);
+            if (s8.toLowerCase() === peg$c29) {
+              peg$currPos += (2);
+            } else {
+              s8 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
+            }
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              peg$silentFails++;
+              s10 = input.charAt(peg$currPos);
+              if (peg$r0.test(s10)) {
+                peg$currPos++;
+              } else {
+                s10 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s10 === peg$FAILED) {
+                s9 = undefined;
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 !== peg$FAILED) {
+                s10 = peg$parse_();
+                s11 = input.substr(peg$currPos, 6);
+                if (s11.toLowerCase() === peg$c31) {
+                  peg$currPos += (6);
+                } else {
+                  s11 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
+                }
+                if (s11 !== peg$FAILED) {
+                  s12 = peg$currPos;
+                  peg$silentFails++;
+                  s13 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s13)) {
+                    peg$currPos++;
+                  } else {
+                    s13 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s13 === peg$FAILED) {
+                    s12 = undefined;
+                  } else {
+                    peg$currPos = s12;
+                    s12 = peg$FAILED;
+                  }
+                  if (s12 !== peg$FAILED) {
+                    s7 = [s7, s8, s9, s10, s11, s12];
+                    s6 = s7;
+                  } else {
+                    peg$currPos = s6;
+                    s6 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s6;
+                  s6 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+            if (s6 === peg$FAILED) {
+              s6 = null;
+            }
+            s7 = peg$parse_();
+            s8 = peg$parseAliasName();
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              s10 = peg$parse_();
+              s11 = peg$parseAlterInPartitionClause();
+              if (s11 !== peg$FAILED) {
+                s10 = [s10, s11];
+                s9 = s10;
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 === peg$FAILED) {
+                s9 = null;
+              }
+              peg$savedPos = s0;
+              s0 = peg$f48(s6, s8, s9);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
   function peg$parseAlterCommandClearIndex() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 33;
+    const key = peg$currPos * 508 + 32;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -11787,11 +12179,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c31) {
+    if (s1.toLowerCase() === peg$c35) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e35); }
+      if (peg$silentFails === 0) { peg$fail(peg$e39); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -11813,11 +12205,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c54) {
+        if (s4.toLowerCase() === peg$c58) {
           peg$currPos += (5);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e59); }
+          if (peg$silentFails === 0) { peg$fail(peg$e63); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -11840,11 +12232,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -11866,11 +12258,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -11928,7 +12320,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f48(s6, s8, s9);
+              s0 = peg$f49(s6, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -11958,7 +12350,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandMaterializeIndex() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 34;
+    const key = peg$currPos * 508 + 33;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -11969,11 +12361,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 11);
-    if (s1.toLowerCase() === peg$c52) {
+    if (s1.toLowerCase() === peg$c56) {
       peg$currPos += (11);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e57); }
+      if (peg$silentFails === 0) { peg$fail(peg$e61); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -11995,11 +12387,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c54) {
+        if (s4.toLowerCase() === peg$c58) {
           peg$currPos += (5);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e59); }
+          if (peg$silentFails === 0) { peg$fail(peg$e63); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -12022,11 +12414,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -12048,11 +12440,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -12110,7 +12502,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f49(s6, s8, s9);
+              s0 = peg$f50(s6, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -12140,7 +12532,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandAddProjection() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 35;
+    const key = peg$currPos * 508 + 34;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -12151,11 +12543,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c23) {
+    if (s1.toLowerCase() === peg$c27) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e27); }
+      if (peg$silentFails === 0) { peg$fail(peg$e31); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -12177,11 +12569,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c58) {
+        if (s4.toLowerCase() === peg$c62) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e63); }
+          if (peg$silentFails === 0) { peg$fail(peg$e67); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -12204,11 +12596,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -12230,11 +12622,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 3);
-                if (s11.toLowerCase() === peg$c26) {
+                if (s11.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -12256,11 +12648,11 @@ function peg$parse(input, options) {
                   if (s12 !== peg$FAILED) {
                     s13 = peg$parse_();
                     s14 = input.substr(peg$currPos, 6);
-                    if (s14.toLowerCase() === peg$c27) {
+                    if (s14.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s14 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s14 !== peg$FAILED) {
                       s15 = peg$currPos;
@@ -12315,11 +12707,11 @@ function peg$parse(input, options) {
               s9 = peg$currPos;
               s10 = peg$parse_();
               s11 = input.substr(peg$currPos, 5);
-              if (s11.toLowerCase() === peg$c28) {
+              if (s11.toLowerCase() === peg$c32) {
                 peg$currPos += (5);
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e32); }
+                if (peg$silentFails === 0) { peg$fail(peg$e36); }
               }
               if (s11 !== peg$FAILED) {
                 s12 = peg$currPos;
@@ -12360,7 +12752,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f50(s6, s8, s9);
+              s0 = peg$f51(s6, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -12390,7 +12782,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandDropProjection() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 36;
+    const key = peg$currPos * 508 + 35;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -12401,11 +12793,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c30) {
+    if (s1.toLowerCase() === peg$c34) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e34); }
+      if (peg$silentFails === 0) { peg$fail(peg$e38); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -12427,11 +12819,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c58) {
+        if (s4.toLowerCase() === peg$c62) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e63); }
+          if (peg$silentFails === 0) { peg$fail(peg$e67); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -12454,11 +12846,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -12480,11 +12872,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -12542,7 +12934,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f51(s6, s8, s9);
+              s0 = peg$f52(s6, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -12572,7 +12964,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandClearProjection() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 37;
+    const key = peg$currPos * 508 + 36;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -12583,11 +12975,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c31) {
+    if (s1.toLowerCase() === peg$c35) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e35); }
+      if (peg$silentFails === 0) { peg$fail(peg$e39); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -12609,11 +13001,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c58) {
+        if (s4.toLowerCase() === peg$c62) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e63); }
+          if (peg$silentFails === 0) { peg$fail(peg$e67); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -12636,11 +13028,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -12662,11 +13054,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -12724,7 +13116,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f52(s6, s8, s9);
+              s0 = peg$f53(s6, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -12754,7 +13146,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandMaterializeProjection() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 38;
+    const key = peg$currPos * 508 + 37;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -12765,11 +13157,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 11);
-    if (s1.toLowerCase() === peg$c52) {
+    if (s1.toLowerCase() === peg$c56) {
       peg$currPos += (11);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e57); }
+      if (peg$silentFails === 0) { peg$fail(peg$e61); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -12791,11 +13183,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c58) {
+        if (s4.toLowerCase() === peg$c62) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e63); }
+          if (peg$silentFails === 0) { peg$fail(peg$e67); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -12818,11 +13210,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -12844,11 +13236,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -12906,7 +13298,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f53(s6, s8, s9);
+              s0 = peg$f54(s6, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -12936,7 +13328,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandAddConstraint() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 39;
+    const key = peg$currPos * 508 + 38;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -12947,11 +13339,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c23) {
+    if (s1.toLowerCase() === peg$c27) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e27); }
+      if (peg$silentFails === 0) { peg$fail(peg$e31); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -12973,11 +13365,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c59) {
+        if (s4.toLowerCase() === peg$c63) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e64); }
+          if (peg$silentFails === 0) { peg$fail(peg$e68); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -13000,11 +13392,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -13026,11 +13418,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 3);
-                if (s11.toLowerCase() === peg$c26) {
+                if (s11.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -13052,11 +13444,11 @@ function peg$parse(input, options) {
                   if (s12 !== peg$FAILED) {
                     s13 = peg$parse_();
                     s14 = input.substr(peg$currPos, 6);
-                    if (s14.toLowerCase() === peg$c27) {
+                    if (s14.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s14 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s14 !== peg$FAILED) {
                       s15 = peg$currPos;
@@ -13109,7 +13501,7 @@ function peg$parse(input, options) {
             s8 = peg$parseAlterConstraintDef();
             if (s8 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f54(s6, s8);
+              s0 = peg$f55(s6, s8);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -13139,7 +13531,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandDropConstraint() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 40;
+    const key = peg$currPos * 508 + 39;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -13150,11 +13542,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c30) {
+    if (s1.toLowerCase() === peg$c34) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e34); }
+      if (peg$silentFails === 0) { peg$fail(peg$e38); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -13176,11 +13568,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c59) {
+        if (s4.toLowerCase() === peg$c63) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e64); }
+          if (peg$silentFails === 0) { peg$fail(peg$e68); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -13203,11 +13595,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -13229,11 +13621,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -13278,7 +13670,7 @@ function peg$parse(input, options) {
             s8 = peg$parseAliasName();
             if (s8 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f55(s6, s8);
+              s0 = peg$f56(s6, s8);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -13308,7 +13700,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandAddStatistics() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 41;
+    const key = peg$currPos * 508 + 40;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -13319,11 +13711,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c23) {
+    if (s1.toLowerCase() === peg$c27) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e27); }
+      if (peg$silentFails === 0) { peg$fail(peg$e31); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -13345,11 +13737,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c42) {
+        if (s4.toLowerCase() === peg$c46) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e46); }
+          if (peg$silentFails === 0) { peg$fail(peg$e50); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -13372,11 +13764,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -13398,11 +13790,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 3);
-                if (s11.toLowerCase() === peg$c26) {
+                if (s11.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -13424,11 +13816,11 @@ function peg$parse(input, options) {
                   if (s12 !== peg$FAILED) {
                     s13 = peg$parse_();
                     s14 = input.substr(peg$currPos, 6);
-                    if (s14.toLowerCase() === peg$c27) {
+                    if (s14.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s14 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s14 !== peg$FAILED) {
                       s15 = peg$currPos;
@@ -13478,15 +13870,15 @@ function peg$parse(input, options) {
               s6 = null;
             }
             s7 = peg$parse_();
-            s8 = peg$parseAlterStatisticsColumns();
+            s8 = peg$parseAliasNameList();
             if (s8 !== peg$FAILED) {
               s9 = peg$parse_();
               s10 = input.substr(peg$currPos, 4);
-              if (s10.toLowerCase() === peg$c33) {
+              if (s10.toLowerCase() === peg$c37) {
                 peg$currPos += (4);
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e37); }
+                if (peg$silentFails === 0) { peg$fail(peg$e41); }
               }
               if (s10 !== peg$FAILED) {
                 s11 = peg$currPos;
@@ -13510,7 +13902,7 @@ function peg$parse(input, options) {
                   s13 = peg$parseAlterStatisticsTypes();
                   if (s13 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f56(s6, s8, s13);
+                    s0 = peg$f57(s6, s8, s13);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -13552,7 +13944,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandDropStatistics() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 42;
+    const key = peg$currPos * 508 + 41;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -13563,11 +13955,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c30) {
+    if (s1.toLowerCase() === peg$c34) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e34); }
+      if (peg$silentFails === 0) { peg$fail(peg$e38); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -13589,11 +13981,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c42) {
+        if (s4.toLowerCase() === peg$c46) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e46); }
+          if (peg$silentFails === 0) { peg$fail(peg$e50); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -13616,11 +14008,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -13642,11 +14034,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -13714,7 +14106,7 @@ function peg$parse(input, options) {
               }
               if (s9 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f57(s6);
+                s0 = peg$f58(s6);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -13742,11 +14134,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c30) {
+      if (s1.toLowerCase() === peg$c34) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e34); }
+        if (peg$silentFails === 0) { peg$fail(peg$e38); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -13768,11 +14160,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 10);
-          if (s4.toLowerCase() === peg$c42) {
+          if (s4.toLowerCase() === peg$c46) {
             peg$currPos += (10);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e46); }
+            if (peg$silentFails === 0) { peg$fail(peg$e50); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -13795,11 +14187,11 @@ function peg$parse(input, options) {
               s6 = peg$currPos;
               s7 = peg$parse_();
               s8 = input.substr(peg$currPos, 2);
-              if (s8.toLowerCase() === peg$c25) {
+              if (s8.toLowerCase() === peg$c29) {
                 peg$currPos += (2);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                if (peg$silentFails === 0) { peg$fail(peg$e33); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -13821,11 +14213,11 @@ function peg$parse(input, options) {
                 if (s9 !== peg$FAILED) {
                   s10 = peg$parse_();
                   s11 = input.substr(peg$currPos, 6);
-                  if (s11.toLowerCase() === peg$c27) {
+                  if (s11.toLowerCase() === peg$c31) {
                     peg$currPos += (6);
                   } else {
                     s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e35); }
                   }
                   if (s11 !== peg$FAILED) {
                     s12 = peg$currPos;
@@ -13867,10 +14259,10 @@ function peg$parse(input, options) {
                 s6 = null;
               }
               s7 = peg$parse_();
-              s8 = peg$parseAlterStatisticsColumns();
+              s8 = peg$parseAliasNameList();
               if (s8 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f58(s6, s8);
+                s0 = peg$f59(s6, s8);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -13901,7 +14293,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandModifyStatistics() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 43;
+    const key = peg$currPos * 508 + 42;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -13912,11 +14304,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c32) {
+    if (s1.toLowerCase() === peg$c36) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e36); }
+      if (peg$silentFails === 0) { peg$fail(peg$e40); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -13938,11 +14330,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c42) {
+        if (s4.toLowerCase() === peg$c46) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e46); }
+          if (peg$silentFails === 0) { peg$fail(peg$e50); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -13965,11 +14357,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -13991,11 +14383,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -14037,15 +14429,15 @@ function peg$parse(input, options) {
               s6 = null;
             }
             s7 = peg$parse_();
-            s8 = peg$parseAlterStatisticsColumns();
+            s8 = peg$parseAliasNameList();
             if (s8 !== peg$FAILED) {
               s9 = peg$parse_();
               s10 = input.substr(peg$currPos, 4);
-              if (s10.toLowerCase() === peg$c33) {
+              if (s10.toLowerCase() === peg$c37) {
                 peg$currPos += (4);
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e37); }
+                if (peg$silentFails === 0) { peg$fail(peg$e41); }
               }
               if (s10 !== peg$FAILED) {
                 s11 = peg$currPos;
@@ -14069,7 +14461,7 @@ function peg$parse(input, options) {
                   s13 = peg$parseAlterStatisticsTypes();
                   if (s13 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f59(s6, s8, s13);
+                    s0 = peg$f60(s6, s8, s13);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -14111,7 +14503,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandClearStatistics() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 44;
+    const key = peg$currPos * 508 + 43;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -14122,11 +14514,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c31) {
+    if (s1.toLowerCase() === peg$c35) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e35); }
+      if (peg$silentFails === 0) { peg$fail(peg$e39); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -14148,11 +14540,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c42) {
+        if (s4.toLowerCase() === peg$c46) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e46); }
+          if (peg$silentFails === 0) { peg$fail(peg$e50); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -14175,11 +14567,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -14201,11 +14593,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -14273,7 +14665,7 @@ function peg$parse(input, options) {
               }
               if (s9 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f60(s6);
+                s0 = peg$f61(s6);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -14301,11 +14693,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c31) {
+      if (s1.toLowerCase() === peg$c35) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e35); }
+        if (peg$silentFails === 0) { peg$fail(peg$e39); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -14327,11 +14719,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 10);
-          if (s4.toLowerCase() === peg$c42) {
+          if (s4.toLowerCase() === peg$c46) {
             peg$currPos += (10);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e46); }
+            if (peg$silentFails === 0) { peg$fail(peg$e50); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -14354,11 +14746,11 @@ function peg$parse(input, options) {
               s6 = peg$currPos;
               s7 = peg$parse_();
               s8 = input.substr(peg$currPos, 2);
-              if (s8.toLowerCase() === peg$c25) {
+              if (s8.toLowerCase() === peg$c29) {
                 peg$currPos += (2);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                if (peg$silentFails === 0) { peg$fail(peg$e33); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -14380,11 +14772,11 @@ function peg$parse(input, options) {
                 if (s9 !== peg$FAILED) {
                   s10 = peg$parse_();
                   s11 = input.substr(peg$currPos, 6);
-                  if (s11.toLowerCase() === peg$c27) {
+                  if (s11.toLowerCase() === peg$c31) {
                     peg$currPos += (6);
                   } else {
                     s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e35); }
                   }
                   if (s11 !== peg$FAILED) {
                     s12 = peg$currPos;
@@ -14426,10 +14818,10 @@ function peg$parse(input, options) {
                 s6 = null;
               }
               s7 = peg$parse_();
-              s8 = peg$parseAlterStatisticsColumns();
+              s8 = peg$parseAliasNameList();
               if (s8 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f61(s6, s8);
+                s0 = peg$f62(s6, s8);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -14460,7 +14852,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandMaterializeStatistics() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 45;
+    const key = peg$currPos * 508 + 44;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -14471,11 +14863,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 11);
-    if (s1.toLowerCase() === peg$c52) {
+    if (s1.toLowerCase() === peg$c56) {
       peg$currPos += (11);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e57); }
+      if (peg$silentFails === 0) { peg$fail(peg$e61); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -14497,11 +14889,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c42) {
+        if (s4.toLowerCase() === peg$c46) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e46); }
+          if (peg$silentFails === 0) { peg$fail(peg$e50); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -14524,11 +14916,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -14550,11 +14942,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -14622,7 +15014,7 @@ function peg$parse(input, options) {
               }
               if (s9 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f62(s6);
+                s0 = peg$f63(s6);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -14650,11 +15042,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 11);
-      if (s1.toLowerCase() === peg$c52) {
+      if (s1.toLowerCase() === peg$c56) {
         peg$currPos += (11);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e57); }
+        if (peg$silentFails === 0) { peg$fail(peg$e61); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -14676,11 +15068,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 10);
-          if (s4.toLowerCase() === peg$c42) {
+          if (s4.toLowerCase() === peg$c46) {
             peg$currPos += (10);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e46); }
+            if (peg$silentFails === 0) { peg$fail(peg$e50); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -14703,11 +15095,11 @@ function peg$parse(input, options) {
               s6 = peg$currPos;
               s7 = peg$parse_();
               s8 = input.substr(peg$currPos, 2);
-              if (s8.toLowerCase() === peg$c25) {
+              if (s8.toLowerCase() === peg$c29) {
                 peg$currPos += (2);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                if (peg$silentFails === 0) { peg$fail(peg$e33); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -14729,11 +15121,11 @@ function peg$parse(input, options) {
                 if (s9 !== peg$FAILED) {
                   s10 = peg$parse_();
                   s11 = input.substr(peg$currPos, 6);
-                  if (s11.toLowerCase() === peg$c27) {
+                  if (s11.toLowerCase() === peg$c31) {
                     peg$currPos += (6);
                   } else {
                     s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e35); }
                   }
                   if (s11 !== peg$FAILED) {
                     s12 = peg$currPos;
@@ -14775,10 +15167,10 @@ function peg$parse(input, options) {
                 s6 = null;
               }
               s7 = peg$parse_();
-              s8 = peg$parseAlterStatisticsColumns();
+              s8 = peg$parseAliasNameList();
               if (s8 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f63(s6, s8);
+                s0 = peg$f64(s6, s8);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -14806,87 +15198,10 @@ function peg$parse(input, options) {
     return s0;
   }
 
-  function peg$parseAlterStatisticsColumns() {
-    let s0, s1, s2, s3, s4, s5, s6, s7;
-
-    const key = peg$currPos * 466 + 46;
-    const cached = peg$resultsCache[key];
-
-    if (cached) {
-      peg$currPos = cached.nextPos;
-
-      return cached.result;
-    }
-
-    s0 = peg$currPos;
-    s1 = peg$parseAliasName();
-    if (s1 !== peg$FAILED) {
-      s2 = [];
-      s3 = peg$currPos;
-      s4 = peg$parse_();
-      if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
-        peg$currPos++;
-      } else {
-        s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
-      }
-      if (s5 !== peg$FAILED) {
-        s6 = peg$parse_();
-        s7 = peg$parseAliasName();
-        if (s7 !== peg$FAILED) {
-          s4 = [s4, s5, s6, s7];
-          s3 = s4;
-        } else {
-          peg$currPos = s3;
-          s3 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
-      }
-      while (s3 !== peg$FAILED) {
-        s2.push(s3);
-        s3 = peg$currPos;
-        s4 = peg$parse_();
-        if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
-          peg$currPos++;
-        } else {
-          s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
-        }
-        if (s5 !== peg$FAILED) {
-          s6 = peg$parse_();
-          s7 = peg$parseAliasName();
-          if (s7 !== peg$FAILED) {
-            s4 = [s4, s5, s6, s7];
-            s3 = s4;
-          } else {
-            peg$currPos = s3;
-            s3 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s3;
-          s3 = peg$FAILED;
-        }
-      }
-      peg$savedPos = s0;
-      s0 = peg$f64(s1, s2);
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
-
-    return s0;
-  }
-
   function peg$parseAlterStatisticsTypes() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 47;
+    const key = peg$currPos * 508 + 45;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -14902,11 +15217,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -14927,11 +15242,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -14963,7 +15278,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandUpdate() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 48;
+    const key = peg$currPos * 508 + 46;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -14974,11 +15289,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c60) {
+    if (s1.toLowerCase() === peg$c64) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e65); }
+      if (peg$silentFails === 0) { peg$fail(peg$e69); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -15006,11 +15321,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 5);
-            if (s8.toLowerCase() === peg$c61) {
+            if (s8.toLowerCase() === peg$c65) {
               peg$currPos += (5);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e66); }
+              if (peg$silentFails === 0) { peg$fail(peg$e70); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -15066,11 +15381,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c60) {
+      if (s1.toLowerCase() === peg$c64) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e65); }
+        if (peg$silentFails === 0) { peg$fail(peg$e69); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -15095,11 +15410,11 @@ function peg$parse(input, options) {
           if (s4 !== peg$FAILED) {
             s5 = peg$parse_();
             s6 = input.substr(peg$currPos, 5);
-            if (s6.toLowerCase() === peg$c61) {
+            if (s6.toLowerCase() === peg$c65) {
               peg$currPos += (5);
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e66); }
+              if (peg$silentFails === 0) { peg$fail(peg$e70); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$currPos;
@@ -15158,7 +15473,7 @@ function peg$parse(input, options) {
   function peg$parseAlterAssignmentList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 49;
+    const key = peg$currPos * 508 + 47;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -15174,11 +15489,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -15199,11 +15514,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -15235,7 +15550,7 @@ function peg$parse(input, options) {
   function peg$parseAlterAssignment() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 50;
+    const key = peg$currPos * 508 + 48;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -15249,11 +15564,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 61) {
-        s3 = peg$c62;
+        s3 = peg$c66;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e67); }
+        if (peg$silentFails === 0) { peg$fail(peg$e71); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -15282,7 +15597,7 @@ function peg$parse(input, options) {
   function peg$parseAlterUpdateAssignmentList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 51;
+    const key = peg$currPos * 508 + 49;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -15298,11 +15613,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -15323,11 +15638,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -15359,7 +15674,7 @@ function peg$parse(input, options) {
   function peg$parseAlterUpdateAssignment() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 52;
+    const key = peg$currPos * 508 + 50;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -15373,11 +15688,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 61) {
-        s3 = peg$c62;
+        s3 = peg$c66;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e67); }
+        if (peg$silentFails === 0) { peg$fail(peg$e71); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -15406,7 +15721,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandDelete() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 53;
+    const key = peg$currPos * 508 + 51;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -15417,11 +15732,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c63) {
+    if (s1.toLowerCase() === peg$c67) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e68); }
+      if (peg$silentFails === 0) { peg$fail(peg$e72); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -15443,11 +15758,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c61) {
+        if (s4.toLowerCase() === peg$c65) {
           peg$currPos += (5);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e66); }
+          if (peg$silentFails === 0) { peg$fail(peg$e70); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -15508,11 +15823,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c63) {
+      if (s1.toLowerCase() === peg$c67) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e68); }
+        if (peg$silentFails === 0) { peg$fail(peg$e72); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -15537,11 +15852,11 @@ function peg$parse(input, options) {
           if (s4 !== peg$FAILED) {
             s5 = peg$parse_();
             s6 = input.substr(peg$currPos, 5);
-            if (s6.toLowerCase() === peg$c61) {
+            if (s6.toLowerCase() === peg$c65) {
               peg$currPos += (5);
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e66); }
+              if (peg$silentFails === 0) { peg$fail(peg$e70); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$currPos;
@@ -15600,7 +15915,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandDropPartition() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 54;
+    const key = peg$currPos * 508 + 52;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -15611,19 +15926,19 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c30) {
+    if (s1.toLowerCase() === peg$c34) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e34); }
+      if (peg$silentFails === 0) { peg$fail(peg$e38); }
     }
     if (s1 === peg$FAILED) {
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c64) {
+      if (s1.toLowerCase() === peg$c68) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e69); }
+        if (peg$silentFails === 0) { peg$fail(peg$e73); }
       }
     }
     if (s1 !== peg$FAILED) {
@@ -15646,11 +15961,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 4);
-        if (s4.toLowerCase() === peg$c65) {
+        if (s4.toLowerCase() === peg$c69) {
           peg$currPos += (4);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e70); }
+          if (peg$silentFails === 0) { peg$fail(peg$e74); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -15672,6 +15987,9 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = peg$parseStringLiteral();
+            if (s7 === peg$FAILED) {
+              s7 = peg$parseQueryParam();
+            }
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
               s0 = peg$f74(s7);
@@ -15698,19 +16016,19 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c30) {
+      if (s1.toLowerCase() === peg$c34) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e34); }
+        if (peg$silentFails === 0) { peg$fail(peg$e38); }
       }
       if (s1 === peg$FAILED) {
         s1 = input.substr(peg$currPos, 6);
-        if (s1.toLowerCase() === peg$c64) {
+        if (s1.toLowerCase() === peg$c68) {
           peg$currPos += (6);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e69); }
+          if (peg$silentFails === 0) { peg$fail(peg$e73); }
         }
       }
       if (s1 !== peg$FAILED) {
@@ -15733,11 +16051,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 9);
-          if (s4.toLowerCase() === peg$c66) {
+          if (s4.toLowerCase() === peg$c70) {
             peg$currPos += (9);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e71); }
+            if (peg$silentFails === 0) { peg$fail(peg$e75); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -15792,7 +16110,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandDropDetachedPartition() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 55;
+    const key = peg$currPos * 508 + 53;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -15803,11 +16121,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c30) {
+    if (s1.toLowerCase() === peg$c34) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e34); }
+      if (peg$silentFails === 0) { peg$fail(peg$e38); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -15829,11 +16147,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 8);
-        if (s4.toLowerCase() === peg$c67) {
+        if (s4.toLowerCase() === peg$c71) {
           peg$currPos += (8);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e72); }
+          if (peg$silentFails === 0) { peg$fail(peg$e76); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -15854,12 +16172,12 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
-            s7 = input.substr(peg$currPos, 9);
-            if (s7.toLowerCase() === peg$c66) {
-              peg$currPos += (9);
+            s7 = input.substr(peg$currPos, 4);
+            if (s7.toLowerCase() === peg$c69) {
+              peg$currPos += (4);
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e71); }
+              if (peg$silentFails === 0) { peg$fail(peg$e74); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$currPos;
@@ -15880,7 +16198,10 @@ function peg$parse(input, options) {
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$parse_();
-                s10 = peg$parseAlterPartitionExpr();
+                s10 = peg$parseStringLiteral();
+                if (s10 === peg$FAILED) {
+                  s10 = peg$parseQueryParam();
+                }
                 if (s10 !== peg$FAILED) {
                   peg$savedPos = s0;
                   s0 = peg$f76(s10);
@@ -15912,6 +16233,119 @@ function peg$parse(input, options) {
       peg$currPos = s0;
       s0 = peg$FAILED;
     }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = input.substr(peg$currPos, 4);
+      if (s1.toLowerCase() === peg$c34) {
+        peg$currPos += (4);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e38); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r0.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parse_();
+          s4 = input.substr(peg$currPos, 8);
+          if (s4.toLowerCase() === peg$c71) {
+            peg$currPos += (8);
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e76); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$currPos;
+            peg$silentFails++;
+            s6 = input.charAt(peg$currPos);
+            if (peg$r0.test(s6)) {
+              peg$currPos++;
+            } else {
+              s6 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s6 === peg$FAILED) {
+              s5 = undefined;
+            } else {
+              peg$currPos = s5;
+              s5 = peg$FAILED;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parse_();
+              s7 = input.substr(peg$currPos, 9);
+              if (s7.toLowerCase() === peg$c70) {
+                peg$currPos += (9);
+              } else {
+                s7 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              }
+              if (s7 !== peg$FAILED) {
+                s8 = peg$currPos;
+                peg$silentFails++;
+                s9 = input.charAt(peg$currPos);
+                if (peg$r0.test(s9)) {
+                  peg$currPos++;
+                } else {
+                  s9 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s9 === peg$FAILED) {
+                  s8 = undefined;
+                } else {
+                  peg$currPos = s8;
+                  s8 = peg$FAILED;
+                }
+                if (s8 !== peg$FAILED) {
+                  s9 = peg$parse_();
+                  s10 = peg$parseAlterPartitionExpr();
+                  if (s10 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s0 = peg$f77(s10);
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
 
     peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
 
@@ -15921,7 +16355,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandAttachPartition() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 56;
+    const key = peg$currPos * 508 + 54;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -15932,11 +16366,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c68) {
+    if (s1.toLowerCase() === peg$c72) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e73); }
+      if (peg$silentFails === 0) { peg$fail(peg$e77); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -15958,11 +16392,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 4);
-        if (s4.toLowerCase() === peg$c65) {
+        if (s4.toLowerCase() === peg$c69) {
           peg$currPos += (4);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e70); }
+          if (peg$silentFails === 0) { peg$fail(peg$e74); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -15984,9 +16418,12 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = peg$parseStringLiteral();
+            if (s7 === peg$FAILED) {
+              s7 = peg$parseQueryParam();
+            }
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f77(s7);
+              s0 = peg$f78(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -16010,11 +16447,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c68) {
+      if (s1.toLowerCase() === peg$c72) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e73); }
+        if (peg$silentFails === 0) { peg$fail(peg$e77); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -16036,11 +16473,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 9);
-          if (s4.toLowerCase() === peg$c66) {
+          if (s4.toLowerCase() === peg$c70) {
             peg$currPos += (9);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e71); }
+            if (peg$silentFails === 0) { peg$fail(peg$e75); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -16065,11 +16502,11 @@ function peg$parse(input, options) {
               if (s7 !== peg$FAILED) {
                 s8 = peg$parse_();
                 s9 = input.substr(peg$currPos, 4);
-                if (s9.toLowerCase() === peg$c69) {
+                if (s9.toLowerCase() === peg$c73) {
                   peg$currPos += (4);
                 } else {
                   s9 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e74); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e78); }
                 }
                 if (s9 !== peg$FAILED) {
                   s10 = peg$currPos;
@@ -16093,7 +16530,7 @@ function peg$parse(input, options) {
                     s12 = peg$parseTableRef();
                     if (s12 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f78(s7, s12);
+                      s0 = peg$f79(s7, s12);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -16129,11 +16566,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 6);
-        if (s1.toLowerCase() === peg$c68) {
+        if (s1.toLowerCase() === peg$c72) {
           peg$currPos += (6);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e73); }
+          if (peg$silentFails === 0) { peg$fail(peg$e77); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -16155,11 +16592,11 @@ function peg$parse(input, options) {
           if (s2 !== peg$FAILED) {
             s3 = peg$parse_();
             s4 = input.substr(peg$currPos, 9);
-            if (s4.toLowerCase() === peg$c66) {
+            if (s4.toLowerCase() === peg$c70) {
               peg$currPos += (9);
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e71); }
+              if (peg$silentFails === 0) { peg$fail(peg$e75); }
             }
             if (s4 !== peg$FAILED) {
               s5 = peg$currPos;
@@ -16185,11 +16622,11 @@ function peg$parse(input, options) {
                   s8 = peg$currPos;
                   s9 = peg$parse_();
                   s10 = input.substr(peg$currPos, 4);
-                  if (s10.toLowerCase() === peg$c69) {
+                  if (s10.toLowerCase() === peg$c73) {
                     peg$currPos += (4);
                   } else {
                     s10 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e74); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e78); }
                   }
                   if (s10 !== peg$FAILED) {
                     s11 = peg$currPos;
@@ -16230,7 +16667,7 @@ function peg$parse(input, options) {
                     s8 = null;
                   }
                   peg$savedPos = s0;
-                  s0 = peg$f79(s7, s8);
+                  s0 = peg$f80(s7, s8);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -16262,7 +16699,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandReplacePartition() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
 
-    const key = peg$currPos * 466 + 57;
+    const key = peg$currPos * 508 + 55;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -16273,11 +16710,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c70) {
+    if (s1.toLowerCase() === peg$c74) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e75); }
+      if (peg$silentFails === 0) { peg$fail(peg$e79); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -16299,11 +16736,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 9);
-        if (s4.toLowerCase() === peg$c66) {
+        if (s4.toLowerCase() === peg$c70) {
           peg$currPos += (9);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e71); }
+          if (peg$silentFails === 0) { peg$fail(peg$e75); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -16328,11 +16765,11 @@ function peg$parse(input, options) {
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
               s9 = input.substr(peg$currPos, 4);
-              if (s9.toLowerCase() === peg$c69) {
+              if (s9.toLowerCase() === peg$c73) {
                 peg$currPos += (4);
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e74); }
+                if (peg$silentFails === 0) { peg$fail(peg$e78); }
               }
               if (s9 !== peg$FAILED) {
                 s10 = peg$currPos;
@@ -16356,7 +16793,7 @@ function peg$parse(input, options) {
                   s12 = peg$parseTableRef();
                   if (s12 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f80(s7, s12);
+                    s0 = peg$f81(s7, s12);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -16398,7 +16835,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandMovePartition() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 58;
+    const key = peg$currPos * 508 + 56;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -16409,11 +16846,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c71) {
+    if (s1.toLowerCase() === peg$c75) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e76); }
+      if (peg$silentFails === 0) { peg$fail(peg$e80); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -16435,11 +16872,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 9);
-        if (s4.toLowerCase() === peg$c66) {
+        if (s4.toLowerCase() === peg$c70) {
           peg$currPos += (9);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e71); }
+          if (peg$silentFails === 0) { peg$fail(peg$e75); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -16491,11 +16928,11 @@ function peg$parse(input, options) {
                   s11 = peg$parse_();
                   s12 = peg$currPos;
                   s13 = input.substr(peg$currPos, 5);
-                  if (s13.toLowerCase() === peg$c20) {
+                  if (s13.toLowerCase() === peg$c23) {
                     peg$currPos += (5);
                   } else {
                     s13 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e24); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e27); }
                   }
                   if (s13 !== peg$FAILED) {
                     s14 = peg$currPos;
@@ -16519,7 +16956,7 @@ function peg$parse(input, options) {
                       s16 = peg$parseTableRef();
                       if (s16 !== peg$FAILED) {
                         peg$savedPos = s12;
-                        s12 = peg$f81(s7, s16);
+                        s12 = peg$f82(s7, s16);
                       } else {
                         peg$currPos = s12;
                         s12 = peg$FAILED;
@@ -16535,11 +16972,11 @@ function peg$parse(input, options) {
                   if (s12 === peg$FAILED) {
                     s12 = peg$currPos;
                     s13 = input.substr(peg$currPos, 4);
-                    if (s13.toLowerCase() === peg$c72) {
+                    if (s13.toLowerCase() === peg$c76) {
                       peg$currPos += (4);
                     } else {
                       s13 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e77); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e81); }
                     }
                     if (s13 !== peg$FAILED) {
                       s14 = peg$currPos;
@@ -16563,7 +17000,7 @@ function peg$parse(input, options) {
                         s16 = peg$parseStringLiteral();
                         if (s16 !== peg$FAILED) {
                           peg$savedPos = s12;
-                          s12 = peg$f82(s7, s16);
+                          s12 = peg$f83(s7, s16);
                         } else {
                           peg$currPos = s12;
                           s12 = peg$FAILED;
@@ -16579,11 +17016,11 @@ function peg$parse(input, options) {
                     if (s12 === peg$FAILED) {
                       s12 = peg$currPos;
                       s13 = input.substr(peg$currPos, 6);
-                      if (s13.toLowerCase() === peg$c73) {
+                      if (s13.toLowerCase() === peg$c77) {
                         peg$currPos += (6);
                       } else {
                         s13 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e78); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e82); }
                       }
                       if (s13 !== peg$FAILED) {
                         s14 = peg$currPos;
@@ -16607,7 +17044,7 @@ function peg$parse(input, options) {
                           s16 = peg$parseStringLiteral();
                           if (s16 !== peg$FAILED) {
                             peg$savedPos = s12;
-                            s12 = peg$f83(s7, s16);
+                            s12 = peg$f84(s7, s16);
                           } else {
                             peg$currPos = s12;
                             s12 = peg$FAILED;
@@ -16623,11 +17060,11 @@ function peg$parse(input, options) {
                       if (s12 === peg$FAILED) {
                         s12 = peg$currPos;
                         s13 = input.substr(peg$currPos, 5);
-                        if (s13.toLowerCase() === peg$c74) {
+                        if (s13.toLowerCase() === peg$c78) {
                           peg$currPos += (5);
                         } else {
                           s13 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e79); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e83); }
                         }
                         if (s13 !== peg$FAILED) {
                           s14 = peg$currPos;
@@ -16651,7 +17088,7 @@ function peg$parse(input, options) {
                             s16 = peg$parseStringLiteral();
                             if (s16 !== peg$FAILED) {
                               peg$savedPos = s12;
-                              s12 = peg$f84(s7, s16);
+                              s12 = peg$f85(s7, s16);
                             } else {
                               peg$currPos = s12;
                               s12 = peg$FAILED;
@@ -16669,7 +17106,7 @@ function peg$parse(input, options) {
                   }
                   if (s12 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f85(s7, s12);
+                    s0 = peg$f86(s7, s12);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -16711,7 +17148,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandFetchPartition() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
 
-    const key = peg$currPos * 466 + 59;
+    const key = peg$currPos * 508 + 57;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -16722,11 +17159,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c75) {
+    if (s1.toLowerCase() === peg$c79) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e80); }
+      if (peg$silentFails === 0) { peg$fail(peg$e84); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -16748,19 +17185,19 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 9);
-        if (s4.toLowerCase() === peg$c66) {
+        if (s4.toLowerCase() === peg$c70) {
           peg$currPos += (9);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e71); }
+          if (peg$silentFails === 0) { peg$fail(peg$e75); }
         }
         if (s4 === peg$FAILED) {
           s4 = input.substr(peg$currPos, 4);
-          if (s4.toLowerCase() === peg$c65) {
+          if (s4.toLowerCase() === peg$c69) {
             peg$currPos += (4);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e70); }
+            if (peg$silentFails === 0) { peg$fail(peg$e74); }
           }
         }
         if (s4 !== peg$FAILED) {
@@ -16786,11 +17223,11 @@ function peg$parse(input, options) {
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
               s9 = input.substr(peg$currPos, 4);
-              if (s9.toLowerCase() === peg$c69) {
+              if (s9.toLowerCase() === peg$c73) {
                 peg$currPos += (4);
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e74); }
+                if (peg$silentFails === 0) { peg$fail(peg$e78); }
               }
               if (s9 !== peg$FAILED) {
                 s10 = peg$currPos;
@@ -16817,7 +17254,7 @@ function peg$parse(input, options) {
                   }
                   if (s12 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f86(s7, s12);
+                    s0 = peg$f87(s7, s12);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -16859,7 +17296,7 @@ function peg$parse(input, options) {
   function peg$parseAlterFetchPartitionExpr() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 60;
+    const key = peg$currPos * 508 + 58;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -16895,7 +17332,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f87();
+        s0 = peg$f88();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -16907,11 +17344,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 2);
-      if (s1.toLowerCase() === peg$c76) {
+      if (s1.toLowerCase() === peg$c80) {
         peg$currPos += (2);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e81); }
+        if (peg$silentFails === 0) { peg$fail(peg$e85); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -16938,7 +17375,7 @@ function peg$parse(input, options) {
           }
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f88(s4);
+            s0 = peg$f89(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -16956,7 +17393,7 @@ function peg$parse(input, options) {
         s1 = peg$parseTernaryExpr();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f89(s1);
+          s1 = peg$f90(s1);
         }
         s0 = s1;
       }
@@ -16970,7 +17407,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandFreezePartition() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 61;
+    const key = peg$currPos * 508 + 59;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -16981,11 +17418,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c77) {
+    if (s1.toLowerCase() === peg$c81) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e82); }
+      if (peg$silentFails === 0) { peg$fail(peg$e86); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -17007,11 +17444,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 9);
-        if (s4.toLowerCase() === peg$c66) {
+        if (s4.toLowerCase() === peg$c70) {
           peg$currPos += (9);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e71); }
+          if (peg$silentFails === 0) { peg$fail(peg$e75); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -17037,11 +17474,11 @@ function peg$parse(input, options) {
               s8 = peg$currPos;
               s9 = peg$parse_();
               s10 = input.substr(peg$currPos, 4);
-              if (s10.toLowerCase() === peg$c53) {
+              if (s10.toLowerCase() === peg$c57) {
                 peg$currPos += (4);
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e58); }
+                if (peg$silentFails === 0) { peg$fail(peg$e62); }
               }
               if (s10 !== peg$FAILED) {
                 s11 = peg$currPos;
@@ -17063,11 +17500,11 @@ function peg$parse(input, options) {
                 if (s11 !== peg$FAILED) {
                   s12 = peg$parse_();
                   s13 = input.substr(peg$currPos, 4);
-                  if (s13.toLowerCase() === peg$c78) {
+                  if (s13.toLowerCase() === peg$c82) {
                     peg$currPos += (4);
                   } else {
                     s13 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e83); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e87); }
                   }
                   if (s13 !== peg$FAILED) {
                     s14 = peg$currPos;
@@ -17116,7 +17553,7 @@ function peg$parse(input, options) {
                 s8 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f90(s7, s8);
+              s0 = peg$f91(s7, s8);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -17146,7 +17583,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandFreezeAll() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 62;
+    const key = peg$currPos * 508 + 60;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -17157,11 +17594,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c77) {
+    if (s1.toLowerCase() === peg$c81) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e82); }
+      if (peg$silentFails === 0) { peg$fail(peg$e86); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -17184,11 +17621,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 4);
-        if (s5.toLowerCase() === peg$c53) {
+        if (s5.toLowerCase() === peg$c57) {
           peg$currPos += (4);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e58); }
+          if (peg$silentFails === 0) { peg$fail(peg$e62); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -17210,11 +17647,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 4);
-            if (s8.toLowerCase() === peg$c78) {
+            if (s8.toLowerCase() === peg$c82) {
               peg$currPos += (4);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e83); }
+              if (peg$silentFails === 0) { peg$fail(peg$e87); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -17263,7 +17700,7 @@ function peg$parse(input, options) {
           s3 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f91(s3);
+        s0 = peg$f92(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -17281,7 +17718,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandModifyTTL() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 63;
+    const key = peg$currPos * 508 + 61;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -17292,11 +17729,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c32) {
+    if (s1.toLowerCase() === peg$c36) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e36); }
+      if (peg$silentFails === 0) { peg$fail(peg$e40); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -17318,11 +17755,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 3);
-        if (s4.toLowerCase() === peg$c41) {
+        if (s4.toLowerCase() === peg$c45) {
           peg$currPos += (3);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e45); }
+          if (peg$silentFails === 0) { peg$fail(peg$e49); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -17349,11 +17786,11 @@ function peg$parse(input, options) {
               s9 = peg$currPos;
               s10 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s11 = peg$c15;
+                s11 = peg$c24;
                 peg$currPos++;
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s11 !== peg$FAILED) {
                 s12 = peg$parse_();
@@ -17374,11 +17811,11 @@ function peg$parse(input, options) {
                 s9 = peg$currPos;
                 s10 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s11 = peg$c15;
+                  s11 = peg$c24;
                   peg$currPos++;
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$parse_();
@@ -17396,7 +17833,7 @@ function peg$parse(input, options) {
                 }
               }
               peg$savedPos = s0;
-              s0 = peg$f92(s7, s8);
+              s0 = peg$f93(s7, s8);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -17426,7 +17863,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandRemoveTTL() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 64;
+    const key = peg$currPos * 508 + 62;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -17437,11 +17874,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c34) {
+    if (s1.toLowerCase() === peg$c38) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e38); }
+      if (peg$silentFails === 0) { peg$fail(peg$e42); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -17463,11 +17900,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 3);
-        if (s4.toLowerCase() === peg$c41) {
+        if (s4.toLowerCase() === peg$c45) {
           peg$currPos += (3);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e45); }
+          if (peg$silentFails === 0) { peg$fail(peg$e49); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -17488,7 +17925,7 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f93();
+            s0 = peg$f94();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -17514,7 +17951,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandMaterializeTTL() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 65;
+    const key = peg$currPos * 508 + 63;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -17525,11 +17962,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 11);
-    if (s1.toLowerCase() === peg$c52) {
+    if (s1.toLowerCase() === peg$c56) {
       peg$currPos += (11);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e57); }
+      if (peg$silentFails === 0) { peg$fail(peg$e61); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -17551,11 +17988,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 3);
-        if (s4.toLowerCase() === peg$c41) {
+        if (s4.toLowerCase() === peg$c45) {
           peg$currPos += (3);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e45); }
+          if (peg$silentFails === 0) { peg$fail(peg$e49); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -17589,7 +18026,7 @@ function peg$parse(input, options) {
               s6 = null;
             }
             peg$savedPos = s0;
-            s0 = peg$f94(s6);
+            s0 = peg$f95(s6);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -17615,7 +18052,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandModifyOrderBy() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 66;
+    const key = peg$currPos * 508 + 64;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -17626,11 +18063,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c32) {
+    if (s1.toLowerCase() === peg$c36) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e36); }
+      if (peg$silentFails === 0) { peg$fail(peg$e40); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -17652,11 +18089,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c79) {
+        if (s4.toLowerCase() === peg$c83) {
           peg$currPos += (5);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e84); }
+          if (peg$silentFails === 0) { peg$fail(peg$e88); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -17678,11 +18115,11 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = input.substr(peg$currPos, 2);
-            if (s7.toLowerCase() === peg$c80) {
+            if (s7.toLowerCase() === peg$c84) {
               peg$currPos += (2);
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e85); }
+              if (peg$silentFails === 0) { peg$fail(peg$e89); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$currPos;
@@ -17706,7 +18143,7 @@ function peg$parse(input, options) {
                 s10 = peg$parseExpression();
                 if (s10 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f95(s10);
+                  s0 = peg$f96(s10);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -17744,7 +18181,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandModifySampleBy() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 67;
+    const key = peg$currPos * 508 + 65;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -17755,11 +18192,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c32) {
+    if (s1.toLowerCase() === peg$c36) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e36); }
+      if (peg$silentFails === 0) { peg$fail(peg$e40); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -17781,11 +18218,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c81) {
+        if (s4.toLowerCase() === peg$c85) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e86); }
+          if (peg$silentFails === 0) { peg$fail(peg$e90); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -17807,11 +18244,11 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = input.substr(peg$currPos, 2);
-            if (s7.toLowerCase() === peg$c80) {
+            if (s7.toLowerCase() === peg$c84) {
               peg$currPos += (2);
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e85); }
+              if (peg$silentFails === 0) { peg$fail(peg$e89); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$currPos;
@@ -17835,7 +18272,7 @@ function peg$parse(input, options) {
                 s10 = peg$parseExpression();
                 if (s10 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f96(s10);
+                  s0 = peg$f97(s10);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -17873,7 +18310,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandRemoveSampleBy() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 68;
+    const key = peg$currPos * 508 + 66;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -17884,11 +18321,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c34) {
+    if (s1.toLowerCase() === peg$c38) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e38); }
+      if (peg$silentFails === 0) { peg$fail(peg$e42); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -17910,11 +18347,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c81) {
+        if (s4.toLowerCase() === peg$c85) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e86); }
+          if (peg$silentFails === 0) { peg$fail(peg$e90); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -17936,11 +18373,11 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = input.substr(peg$currPos, 2);
-            if (s7.toLowerCase() === peg$c80) {
+            if (s7.toLowerCase() === peg$c84) {
               peg$currPos += (2);
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e85); }
+              if (peg$silentFails === 0) { peg$fail(peg$e89); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$currPos;
@@ -17961,7 +18398,7 @@ function peg$parse(input, options) {
               }
               if (s8 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f97();
+                s0 = peg$f98();
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -17995,7 +18432,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandModifySetting() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 69;
+    const key = peg$currPos * 508 + 67;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -18006,11 +18443,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c32) {
+    if (s1.toLowerCase() === peg$c36) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e36); }
+      if (peg$silentFails === 0) { peg$fail(peg$e40); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -18032,11 +18469,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 7);
-        if (s4.toLowerCase() === peg$c50) {
+        if (s4.toLowerCase() === peg$c54) {
           peg$currPos += (7);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e55); }
+          if (peg$silentFails === 0) { peg$fail(peg$e59); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -18060,7 +18497,7 @@ function peg$parse(input, options) {
             s7 = peg$parseSettingsList();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f98(s7);
+              s0 = peg$f99(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -18090,7 +18527,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandResetSetting() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 70;
+    const key = peg$currPos * 508 + 68;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -18101,11 +18538,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c45) {
+    if (s1.toLowerCase() === peg$c49) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e49); }
+      if (peg$silentFails === 0) { peg$fail(peg$e53); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -18127,11 +18564,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 7);
-        if (s4.toLowerCase() === peg$c50) {
+        if (s4.toLowerCase() === peg$c54) {
           peg$currPos += (7);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e55); }
+          if (peg$silentFails === 0) { peg$fail(peg$e59); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -18152,10 +18589,10 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
-            s7 = peg$parseAlterResetSettingNames();
+            s7 = peg$parseAliasNameList();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f99(s7);
+              s0 = peg$f100(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -18182,10 +18619,10 @@ function peg$parse(input, options) {
     return s0;
   }
 
-  function peg$parseAlterResetSettingNames() {
+  function peg$parseAlterCommandModifyQuery() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 71;
+    const key = peg$currPos * 508 + 69;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -18195,60 +18632,78 @@ function peg$parse(input, options) {
     }
 
     s0 = peg$currPos;
-    s1 = peg$parseAliasName();
+    s1 = input.substr(peg$currPos, 6);
+    if (s1.toLowerCase() === peg$c36) {
+      peg$currPos += (6);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e40); }
+    }
     if (s1 !== peg$FAILED) {
-      s2 = [];
-      s3 = peg$currPos;
-      s4 = peg$parse_();
-      if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
         peg$currPos++;
       } else {
-        s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
       }
-      if (s5 !== peg$FAILED) {
-        s6 = peg$parse_();
-        s7 = peg$parseAliasName();
-        if (s7 !== peg$FAILED) {
-          s4 = [s4, s5, s6, s7];
-          s3 = s4;
-        } else {
-          peg$currPos = s3;
-          s3 = peg$FAILED;
-        }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
       } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
+        peg$currPos = s2;
+        s2 = peg$FAILED;
       }
-      while (s3 !== peg$FAILED) {
-        s2.push(s3);
-        s3 = peg$currPos;
-        s4 = peg$parse_();
-        if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
-          peg$currPos++;
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = input.substr(peg$currPos, 5);
+        if (s4.toLowerCase() === peg$c86) {
+          peg$currPos += (5);
         } else {
-          s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e91); }
         }
-        if (s5 !== peg$FAILED) {
-          s6 = peg$parse_();
-          s7 = peg$parseAliasName();
-          if (s7 !== peg$FAILED) {
-            s4 = [s4, s5, s6, s7];
-            s3 = s4;
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          peg$silentFails++;
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
           } else {
-            peg$currPos = s3;
-            s3 = peg$FAILED;
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s6 === peg$FAILED) {
+            s5 = undefined;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parse_();
+            s7 = peg$parseUnionQuery();
+            if (s7 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f101(s7);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
           }
         } else {
-          peg$currPos = s3;
-          s3 = peg$FAILED;
+          peg$currPos = s0;
+          s0 = peg$FAILED;
         }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
       }
-      peg$savedPos = s0;
-      s0 = peg$f100(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -18259,10 +18714,10 @@ function peg$parse(input, options) {
     return s0;
   }
 
-  function peg$parseAlterCommandModifyQuery() {
+  function peg$parseAlterCommandModifyComment() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 72;
+    const key = peg$currPos * 508 + 70;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -18273,11 +18728,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c32) {
+    if (s1.toLowerCase() === peg$c36) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e36); }
+      if (peg$silentFails === 0) { peg$fail(peg$e40); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -18298,12 +18753,12 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
-        s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c82) {
-          peg$currPos += (5);
+        s4 = input.substr(peg$currPos, 7);
+        if (s4.toLowerCase() === peg$c43) {
+          peg$currPos += (7);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e87); }
+          if (peg$silentFails === 0) { peg$fail(peg$e47); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -18324,10 +18779,10 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
-            s7 = peg$parseUnionQuery();
+            s7 = peg$parseStringLiteral();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f101(s7);
+              s0 = peg$f102(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -18354,10 +18809,10 @@ function peg$parse(input, options) {
     return s0;
   }
 
-  function peg$parseAlterCommandModifyComment() {
-    let s0, s1, s2, s3, s4, s5, s6, s7;
+  function peg$parseAlterCommandModifyRefresh() {
+    let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 73;
+    const key = peg$currPos * 508 + 71;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -18368,11 +18823,72 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c32) {
+    if (s1.toLowerCase() === peg$c36) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e36); }
+      if (peg$silentFails === 0) { peg$fail(peg$e40); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = peg$parseRefreshClause();
+        if (s4 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f103(s4);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseAlterCommandApplyDeletedMask() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    const key = peg$currPos * 508 + 72;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 5);
+    if (s1.toLowerCase() === peg$c87) {
+      peg$currPos += (5);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e92); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -18394,11 +18910,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 7);
-        if (s4.toLowerCase() === peg$c39) {
+        if (s4.toLowerCase() === peg$c88) {
           peg$currPos += (7);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e43); }
+          if (peg$silentFails === 0) { peg$fail(peg$e93); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -18419,145 +18935,50 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
-            s7 = peg$parseStringLiteral();
+            s7 = input.substr(peg$currPos, 4);
+            if (s7.toLowerCase() === peg$c89) {
+              peg$currPos += (4);
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e94); }
+            }
             if (s7 !== peg$FAILED) {
-              peg$savedPos = s0;
-              s0 = peg$f102(s7);
-            } else {
-              peg$currPos = s0;
-              s0 = peg$FAILED;
-            }
-          } else {
-            peg$currPos = s0;
-            s0 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
-
-    return s0;
-  }
-
-  function peg$parseAlterCommandApplyDeletedMask() {
-    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
-
-    const key = peg$currPos * 466 + 74;
-    const cached = peg$resultsCache[key];
-
-    if (cached) {
-      peg$currPos = cached.nextPos;
-
-      return cached.result;
-    }
-
-    s0 = peg$currPos;
-    s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c83) {
-      peg$currPos += (5);
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e88); }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = peg$currPos;
-      peg$silentFails++;
-      s3 = input.charAt(peg$currPos);
-      if (peg$r0.test(s3)) {
-        peg$currPos++;
-      } else {
-        s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e2); }
-      }
-      peg$silentFails--;
-      if (s3 === peg$FAILED) {
-        s2 = undefined;
-      } else {
-        peg$currPos = s2;
-        s2 = peg$FAILED;
-      }
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parse_();
-        s4 = input.substr(peg$currPos, 7);
-        if (s4.toLowerCase() === peg$c84) {
-          peg$currPos += (7);
-        } else {
-          s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e89); }
-        }
-        if (s4 !== peg$FAILED) {
-          s5 = peg$currPos;
-          peg$silentFails++;
-          s6 = input.charAt(peg$currPos);
-          if (peg$r0.test(s6)) {
-            peg$currPos++;
-          } else {
-            s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e2); }
-          }
-          peg$silentFails--;
-          if (s6 === peg$FAILED) {
-            s5 = undefined;
-          } else {
-            peg$currPos = s5;
-            s5 = peg$FAILED;
-          }
-          if (s5 !== peg$FAILED) {
-            s6 = peg$parse_();
-            s7 = input.substr(peg$currPos, 4);
-            if (s7.toLowerCase() === peg$c85) {
-              peg$currPos += (4);
-            } else {
-              s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e90); }
-            }
-            if (s7 !== peg$FAILED) {
-              s8 = peg$currPos;
-              peg$silentFails++;
-              s9 = input.charAt(peg$currPos);
-              if (peg$r0.test(s9)) {
-                peg$currPos++;
-              } else {
-                s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e2); }
-              }
-              peg$silentFails--;
-              if (s9 === peg$FAILED) {
-                s8 = undefined;
-              } else {
-                peg$currPos = s8;
-                s8 = peg$FAILED;
-              }
-              if (s8 !== peg$FAILED) {
-                s9 = peg$currPos;
-                s10 = peg$parse_();
-                s11 = peg$parseAlterInPartitionClause();
-                if (s11 !== peg$FAILED) {
-                  s10 = [s10, s11];
-                  s9 = s10;
-                } else {
-                  peg$currPos = s9;
-                  s9 = peg$FAILED;
-                }
-                if (s9 === peg$FAILED) {
-                  s9 = null;
-                }
-                peg$savedPos = s0;
-                s0 = peg$f103(s9);
-              } else {
-                peg$currPos = s0;
-                s0 = peg$FAILED;
-              }
+              s8 = peg$currPos;
+              peg$silentFails++;
+              s9 = input.charAt(peg$currPos);
+              if (peg$r0.test(s9)) {
+                peg$currPos++;
+              } else {
+                s9 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s9 === peg$FAILED) {
+                s8 = undefined;
+              } else {
+                peg$currPos = s8;
+                s8 = peg$FAILED;
+              }
+              if (s8 !== peg$FAILED) {
+                s9 = peg$currPos;
+                s10 = peg$parse_();
+                s11 = peg$parseAlterInPartitionClause();
+                if (s11 !== peg$FAILED) {
+                  s10 = [s10, s11];
+                  s9 = s10;
+                } else {
+                  peg$currPos = s9;
+                  s9 = peg$FAILED;
+                }
+                if (s9 === peg$FAILED) {
+                  s9 = null;
+                }
+                peg$savedPos = s0;
+                s0 = peg$f104(s9);
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -18587,7 +19008,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandApplyPatches() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 75;
+    const key = peg$currPos * 508 + 73;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -18598,11 +19019,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c83) {
+    if (s1.toLowerCase() === peg$c87) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e88); }
+      if (peg$silentFails === 0) { peg$fail(peg$e92); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -18624,11 +19045,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 7);
-        if (s4.toLowerCase() === peg$c86) {
+        if (s4.toLowerCase() === peg$c90) {
           peg$currPos += (7);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e91); }
+          if (peg$silentFails === 0) { peg$fail(peg$e95); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -18662,7 +19083,7 @@ function peg$parse(input, options) {
               s6 = null;
             }
             peg$savedPos = s0;
-            s0 = peg$f104(s6);
+            s0 = peg$f105(s6);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -18688,7 +19109,7 @@ function peg$parse(input, options) {
   function peg$parseAlterCommandRewriteParts() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 76;
+    const key = peg$currPos * 508 + 74;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -18699,11 +19120,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c87) {
+    if (s1.toLowerCase() === peg$c91) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e92); }
+      if (peg$silentFails === 0) { peg$fail(peg$e96); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -18725,11 +19146,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c88) {
+        if (s4.toLowerCase() === peg$c92) {
           peg$currPos += (5);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e93); }
+          if (peg$silentFails === 0) { peg$fail(peg$e97); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -18763,7 +19184,7 @@ function peg$parse(input, options) {
               s6 = null;
             }
             peg$savedPos = s0;
-            s0 = peg$f105(s6);
+            s0 = peg$f106(s6);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -18789,7 +19210,7 @@ function peg$parse(input, options) {
   function peg$parseAlterPartitionExpr() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 77;
+    const key = peg$currPos * 508 + 75;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -18825,7 +19246,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f106();
+        s0 = peg$f107();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -18837,11 +19258,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 2);
-      if (s1.toLowerCase() === peg$c76) {
+      if (s1.toLowerCase() === peg$c80) {
         peg$currPos += (2);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e81); }
+        if (peg$silentFails === 0) { peg$fail(peg$e85); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -18868,7 +19289,7 @@ function peg$parse(input, options) {
           }
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f107(s4);
+            s0 = peg$f108(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -18886,7 +19307,7 @@ function peg$parse(input, options) {
         s1 = peg$parseTernaryExpr();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f108(s1);
+          s1 = peg$f109(s1);
         }
         s0 = s1;
       }
@@ -18900,7 +19321,7 @@ function peg$parse(input, options) {
   function peg$parseAlterInPartitionClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 78;
+    const key = peg$currPos * 508 + 76;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -18911,11 +19332,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c89) {
+    if (s1.toLowerCase() === peg$c93) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e94); }
+      if (peg$silentFails === 0) { peg$fail(peg$e98); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -18937,11 +19358,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 9);
-        if (s4.toLowerCase() === peg$c66) {
+        if (s4.toLowerCase() === peg$c70) {
           peg$currPos += (9);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e71); }
+          if (peg$silentFails === 0) { peg$fail(peg$e75); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -18965,7 +19386,7 @@ function peg$parse(input, options) {
             s7 = peg$parseAlterPartitionExpr();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f109(s7);
+              s0 = peg$f110(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -18989,11 +19410,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 2);
-      if (s1.toLowerCase() === peg$c89) {
+      if (s1.toLowerCase() === peg$c93) {
         peg$currPos += (2);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e94); }
+        if (peg$silentFails === 0) { peg$fail(peg$e98); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -19015,11 +19436,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 4);
-          if (s4.toLowerCase() === peg$c65) {
+          if (s4.toLowerCase() === peg$c69) {
             peg$currPos += (4);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e70); }
+            if (peg$silentFails === 0) { peg$fail(peg$e74); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -19043,7 +19464,7 @@ function peg$parse(input, options) {
               s7 = peg$parseStringLiteral();
               if (s7 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f110(s7);
+                s0 = peg$f111(s7);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -19071,314 +19492,10 @@ function peg$parse(input, options) {
     return s0;
   }
 
-  function peg$parseOpaqueStatement() {
-    let s0, s1, s2, s3, s4, s5, s6, s7, s8;
-
-    const key = peg$currPos * 466 + 79;
-    const cached = peg$resultsCache[key];
-
-    if (cached) {
-      peg$currPos = cached.nextPos;
-
-      return cached.result;
-    }
-
-    s0 = peg$currPos;
-    s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c18) {
-      peg$currPos += (5);
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e22); }
-    }
-    if (s1 === peg$FAILED) {
-      s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c68) {
-        peg$currPos += (6);
-      } else {
-        s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e73); }
-      }
-      if (s1 === peg$FAILED) {
-        s1 = input.substr(peg$currPos, 6);
-        if (s1.toLowerCase() === peg$c64) {
-          peg$currPos += (6);
-        } else {
-          s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e69); }
-        }
-        if (s1 === peg$FAILED) {
-          s1 = input.substr(peg$currPos, 6);
-          if (s1.toLowerCase() === peg$c51) {
-            peg$currPos += (6);
-          } else {
-            s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e56); }
-          }
-          if (s1 === peg$FAILED) {
-            s1 = input.substr(peg$currPos, 8);
-            if (s1.toLowerCase() === peg$c90) {
-              peg$currPos += (8);
-            } else {
-              s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e95); }
-            }
-            if (s1 === peg$FAILED) {
-              s1 = input.substr(peg$currPos, 5);
-              if (s1.toLowerCase() === peg$c55) {
-                peg$currPos += (5);
-              } else {
-                s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e60); }
-              }
-              if (s1 === peg$FAILED) {
-                s1 = input.substr(peg$currPos, 6);
-                if (s1.toLowerCase() === peg$c27) {
-                  peg$currPos += (6);
-                } else {
-                  s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
-                }
-                if (s1 === peg$FAILED) {
-                  s1 = input.substr(peg$currPos, 4);
-                  if (s1.toLowerCase() === peg$c91) {
-                    peg$currPos += (4);
-                  } else {
-                    s1 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e96); }
-                  }
-                  if (s1 === peg$FAILED) {
-                    s1 = input.substr(peg$currPos, 5);
-                    if (s1.toLowerCase() === peg$c92) {
-                      peg$currPos += (5);
-                    } else {
-                      s1 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e97); }
-                    }
-                    if (s1 === peg$FAILED) {
-                      s1 = input.substr(peg$currPos, 6);
-                      if (s1.toLowerCase() === peg$c93) {
-                        peg$currPos += (6);
-                      } else {
-                        s1 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e98); }
-                      }
-                      if (s1 === peg$FAILED) {
-                        s1 = input.substr(peg$currPos, 4);
-                        if (s1.toLowerCase() === peg$c94) {
-                          peg$currPos += (4);
-                        } else {
-                          s1 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e99); }
-                        }
-                        if (s1 === peg$FAILED) {
-                          s1 = input.substr(peg$currPos, 4);
-                          if (s1.toLowerCase() === peg$c95) {
-                            peg$currPos += (4);
-                          } else {
-                            s1 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e100); }
-                          }
-                          if (s1 === peg$FAILED) {
-                            s1 = input.substr(peg$currPos, 6);
-                            if (s1.toLowerCase() === peg$c96) {
-                              peg$currPos += (6);
-                            } else {
-                              s1 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e101); }
-                            }
-                            if (s1 === peg$FAILED) {
-                              s1 = input.substr(peg$currPos, 7);
-                              if (s1.toLowerCase() === peg$c97) {
-                                peg$currPos += (7);
-                              } else {
-                                s1 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e102); }
-                              }
-                              if (s1 === peg$FAILED) {
-                                s1 = input.substr(peg$currPos, 5);
-                                if (s1.toLowerCase() === peg$c98) {
-                                  peg$currPos += (5);
-                                } else {
-                                  s1 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e103); }
-                                }
-                                if (s1 === peg$FAILED) {
-                                  s1 = input.substr(peg$currPos, 6);
-                                  if (s1.toLowerCase() === peg$c99) {
-                                    peg$currPos += (6);
-                                  } else {
-                                    s1 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e104); }
-                                  }
-                                  if (s1 === peg$FAILED) {
-                                    s1 = input.substr(peg$currPos, 8);
-                                    if (s1.toLowerCase() === peg$c100) {
-                                      peg$currPos += (8);
-                                    } else {
-                                      s1 = peg$FAILED;
-                                      if (peg$silentFails === 0) { peg$fail(peg$e105); }
-                                    }
-                                    if (s1 === peg$FAILED) {
-                                      s1 = input.substr(peg$currPos, 5);
-                                      if (s1.toLowerCase() === peg$c101) {
-                                        peg$currPos += (5);
-                                      } else {
-                                        s1 = peg$FAILED;
-                                        if (peg$silentFails === 0) { peg$fail(peg$e106); }
-                                      }
-                                      if (s1 === peg$FAILED) {
-                                        s1 = input.substr(peg$currPos, 6);
-                                        if (s1.toLowerCase() === peg$c102) {
-                                          peg$currPos += (6);
-                                        } else {
-                                          s1 = peg$FAILED;
-                                          if (peg$silentFails === 0) { peg$fail(peg$e107); }
-                                        }
-                                        if (s1 === peg$FAILED) {
-                                          s1 = input.substr(peg$currPos, 4);
-                                          if (s1.toLowerCase() === peg$c71) {
-                                            peg$currPos += (4);
-                                          } else {
-                                            s1 = peg$FAILED;
-                                            if (peg$silentFails === 0) { peg$fail(peg$e76); }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = peg$currPos;
-      peg$silentFails++;
-      s3 = input.charAt(peg$currPos);
-      if (peg$r0.test(s3)) {
-        peg$currPos++;
-      } else {
-        s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e2); }
-      }
-      peg$silentFails--;
-      if (s3 === peg$FAILED) {
-        s2 = undefined;
-      } else {
-        peg$currPos = s2;
-        s2 = peg$FAILED;
-      }
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parse_();
-        s4 = peg$currPos;
-        s5 = [];
-        s6 = peg$currPos;
-        s7 = peg$currPos;
-        peg$silentFails++;
-        s8 = input.charAt(peg$currPos);
-        if (peg$r2.test(s8)) {
-          peg$currPos++;
-        } else {
-          s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e20); }
-        }
-        peg$silentFails--;
-        if (s8 === peg$FAILED) {
-          s7 = undefined;
-        } else {
-          peg$currPos = s7;
-          s7 = peg$FAILED;
-        }
-        if (s7 !== peg$FAILED) {
-          if (input.length > peg$currPos) {
-            s8 = input.charAt(peg$currPos);
-            peg$currPos++;
-          } else {
-            s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e21); }
-          }
-          if (s8 !== peg$FAILED) {
-            s7 = [s7, s8];
-            s6 = s7;
-          } else {
-            peg$currPos = s6;
-            s6 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s6;
-          s6 = peg$FAILED;
-        }
-        while (s6 !== peg$FAILED) {
-          s5.push(s6);
-          s6 = peg$currPos;
-          s7 = peg$currPos;
-          peg$silentFails++;
-          s8 = input.charAt(peg$currPos);
-          if (peg$r2.test(s8)) {
-            peg$currPos++;
-          } else {
-            s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e20); }
-          }
-          peg$silentFails--;
-          if (s8 === peg$FAILED) {
-            s7 = undefined;
-          } else {
-            peg$currPos = s7;
-            s7 = peg$FAILED;
-          }
-          if (s7 !== peg$FAILED) {
-            if (input.length > peg$currPos) {
-              s8 = input.charAt(peg$currPos);
-              peg$currPos++;
-            } else {
-              s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e21); }
-            }
-            if (s8 !== peg$FAILED) {
-              s7 = [s7, s8];
-              s6 = s7;
-            } else {
-              peg$currPos = s6;
-              s6 = peg$FAILED;
-            }
-          } else {
-            peg$currPos = s6;
-            s6 = peg$FAILED;
-          }
-        }
-        s4 = input.substring(s4, peg$currPos);
-        peg$savedPos = s0;
-        s0 = peg$f111(s1, s4);
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
-
-    return s0;
-  }
-
   function peg$parseDropIndexStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 80;
+    const key = peg$currPos * 508 + 77;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -19389,11 +19506,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c30) {
+    if (s1.toLowerCase() === peg$c34) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e34); }
+      if (peg$silentFails === 0) { peg$fail(peg$e38); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -19415,11 +19532,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c54) {
+        if (s4.toLowerCase() === peg$c58) {
           peg$currPos += (5);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e59); }
+          if (peg$silentFails === 0) { peg$fail(peg$e63); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -19442,11 +19559,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -19468,11 +19585,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -19518,11 +19635,11 @@ function peg$parse(input, options) {
             if (s8 !== peg$FAILED) {
               s9 = peg$parse_();
               s10 = input.substr(peg$currPos, 2);
-              if (s10.toLowerCase() === peg$c103) {
+              if (s10.toLowerCase() === peg$c94) {
                 peg$currPos += (2);
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e108); }
+                if (peg$silentFails === 0) { peg$fail(peg$e99); }
               }
               if (s10 !== peg$FAILED) {
                 s11 = peg$currPos;
@@ -19588,7 +19705,7 @@ function peg$parse(input, options) {
   function peg$parseDropStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
 
-    const key = peg$currPos * 466 + 81;
+    const key = peg$currPos * 508 + 78;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -19601,11 +19718,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c30) {
+      if (s1.toLowerCase() === peg$c34) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e34); }
+        if (peg$silentFails === 0) { peg$fail(peg$e38); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -19628,11 +19745,11 @@ function peg$parse(input, options) {
           s3 = peg$currPos;
           s4 = peg$parse_();
           s5 = input.substr(peg$currPos, 9);
-          if (s5.toLowerCase() === peg$c19) {
+          if (s5.toLowerCase() === peg$c22) {
             peg$currPos += (9);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e23); }
+            if (peg$silentFails === 0) { peg$fail(peg$e26); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$currPos;
@@ -19671,11 +19788,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -19697,19 +19814,19 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 === peg$FAILED) {
                   s11 = input.substr(peg$currPos, 5);
-                  if (s11.toLowerCase() === peg$c104) {
+                  if (s11.toLowerCase() === peg$c95) {
                     peg$currPos += (5);
                   } else {
                     s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e109); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e100); }
                   }
                 }
                 if (s11 !== peg$FAILED) {
@@ -19758,11 +19875,11 @@ function peg$parse(input, options) {
               s10 = peg$currPos;
               s11 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s12 = peg$c15;
+                s12 = peg$c24;
                 peg$currPos++;
               } else {
                 s12 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s12 !== peg$FAILED) {
                 s13 = peg$parse_();
@@ -19783,11 +19900,11 @@ function peg$parse(input, options) {
                 s10 = peg$currPos;
                 s11 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s12 = peg$c15;
+                  s12 = peg$c24;
                   peg$currPos++;
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$parse_();
@@ -19820,20 +19937,20 @@ function peg$parse(input, options) {
               s11 = peg$currPos;
               s12 = peg$parse_();
               s13 = input.substr(peg$currPos, 4);
-              if (s13.toLowerCase() === peg$c105) {
+              if (s13.toLowerCase() === peg$c96) {
                 peg$currPos += (4);
               } else {
                 s13 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e110); }
+                if (peg$silentFails === 0) { peg$fail(peg$e101); }
               }
               if (s13 === peg$FAILED) {
                 s13 = peg$currPos;
                 s14 = input.substr(peg$currPos, 2);
-                if (s14.toLowerCase() === peg$c106) {
+                if (s14.toLowerCase() === peg$c97) {
                   peg$currPos += (2);
                 } else {
                   s14 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e111); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e102); }
                 }
                 if (s14 !== peg$FAILED) {
                   s15 = peg$currPos;
@@ -19855,11 +19972,11 @@ function peg$parse(input, options) {
                   if (s15 !== peg$FAILED) {
                     s16 = peg$parse_();
                     s17 = input.substr(peg$currPos, 5);
-                    if (s17.toLowerCase() === peg$c107) {
+                    if (s17.toLowerCase() === peg$c98) {
                       peg$currPos += (5);
                     } else {
                       s17 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e112); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e103); }
                     }
                     if (s17 !== peg$FAILED) {
                       s14 = [s14, s15, s16, s17];
@@ -19957,11 +20074,11 @@ function peg$parse(input, options) {
         s1 = peg$currPos;
         s2 = peg$currPos;
         s3 = input.substr(peg$currPos, 4);
-        if (s3.toLowerCase() === peg$c30) {
+        if (s3.toLowerCase() === peg$c34) {
           peg$currPos += (4);
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e34); }
+          if (peg$silentFails === 0) { peg$fail(peg$e38); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$currPos;
@@ -19984,47 +20101,47 @@ function peg$parse(input, options) {
             s5 = [];
             s6 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 39) {
-              s7 = peg$c108;
+              s7 = peg$c99;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e113); }
+              if (peg$silentFails === 0) { peg$fail(peg$e104); }
             }
             if (s7 !== peg$FAILED) {
               s8 = [];
-              if (input.substr(peg$currPos, 2) === peg$c109) {
-                s9 = peg$c109;
+              if (input.substr(peg$currPos, 2) === peg$c100) {
+                s9 = peg$c100;
                 peg$currPos += 2;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e114); }
+                if (peg$silentFails === 0) { peg$fail(peg$e105); }
               }
               if (s9 === peg$FAILED) {
-                if (input.substr(peg$currPos, 2) === peg$c110) {
-                  s9 = peg$c110;
+                if (input.substr(peg$currPos, 2) === peg$c101) {
+                  s9 = peg$c101;
                   peg$currPos += 2;
                 } else {
                   s9 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e115); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e106); }
                 }
                 if (s9 === peg$FAILED) {
-                  if (input.substr(peg$currPos, 2) === peg$c111) {
-                    s9 = peg$c111;
+                  if (input.substr(peg$currPos, 2) === peg$c102) {
+                    s9 = peg$c102;
                     peg$currPos += 2;
                   } else {
                     s9 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e116); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e107); }
                   }
                   if (s9 === peg$FAILED) {
                     s9 = peg$currPos;
                     s10 = peg$currPos;
                     peg$silentFails++;
                     if (input.charCodeAt(peg$currPos) === 39) {
-                      s11 = peg$c108;
+                      s11 = peg$c99;
                       peg$currPos++;
                     } else {
                       s11 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e104); }
                     }
                     peg$silentFails--;
                     if (s11 === peg$FAILED) {
@@ -20039,7 +20156,7 @@ function peg$parse(input, options) {
                         peg$currPos++;
                       } else {
                         s11 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e117); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e108); }
                       }
                       if (s11 === peg$FAILED) {
                         if (input.length > peg$currPos) {
@@ -20047,7 +20164,7 @@ function peg$parse(input, options) {
                           peg$currPos++;
                         } else {
                           s11 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e24); }
                         }
                       }
                       if (s11 !== peg$FAILED) {
@@ -20066,39 +20183,39 @@ function peg$parse(input, options) {
               }
               while (s9 !== peg$FAILED) {
                 s8.push(s9);
-                if (input.substr(peg$currPos, 2) === peg$c109) {
-                  s9 = peg$c109;
+                if (input.substr(peg$currPos, 2) === peg$c100) {
+                  s9 = peg$c100;
                   peg$currPos += 2;
                 } else {
                   s9 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e114); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e105); }
                 }
                 if (s9 === peg$FAILED) {
-                  if (input.substr(peg$currPos, 2) === peg$c110) {
-                    s9 = peg$c110;
+                  if (input.substr(peg$currPos, 2) === peg$c101) {
+                    s9 = peg$c101;
                     peg$currPos += 2;
                   } else {
                     s9 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e115); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e106); }
                   }
                   if (s9 === peg$FAILED) {
-                    if (input.substr(peg$currPos, 2) === peg$c111) {
-                      s9 = peg$c111;
+                    if (input.substr(peg$currPos, 2) === peg$c102) {
+                      s9 = peg$c102;
                       peg$currPos += 2;
                     } else {
                       s9 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e116); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e107); }
                     }
                     if (s9 === peg$FAILED) {
                       s9 = peg$currPos;
                       s10 = peg$currPos;
                       peg$silentFails++;
                       if (input.charCodeAt(peg$currPos) === 39) {
-                        s11 = peg$c108;
+                        s11 = peg$c99;
                         peg$currPos++;
                       } else {
                         s11 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e104); }
                       }
                       peg$silentFails--;
                       if (s11 === peg$FAILED) {
@@ -20113,7 +20230,7 @@ function peg$parse(input, options) {
                           peg$currPos++;
                         } else {
                           s11 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e117); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e108); }
                         }
                         if (s11 === peg$FAILED) {
                           if (input.length > peg$currPos) {
@@ -20121,7 +20238,7 @@ function peg$parse(input, options) {
                             peg$currPos++;
                           } else {
                             s11 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e24); }
                           }
                         }
                         if (s11 !== peg$FAILED) {
@@ -20140,11 +20257,11 @@ function peg$parse(input, options) {
                 }
               }
               if (input.charCodeAt(peg$currPos) === 39) {
-                s9 = peg$c108;
+                s9 = peg$c99;
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                if (peg$silentFails === 0) { peg$fail(peg$e104); }
               }
               if (s9 !== peg$FAILED) {
                 s7 = [s7, s8, s9];
@@ -20181,7 +20298,7 @@ function peg$parse(input, options) {
                   peg$currPos++;
                 } else {
                   s8 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e117); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e108); }
                 }
                 if (s8 === peg$FAILED) {
                   if (input.length > peg$currPos) {
@@ -20189,7 +20306,7 @@ function peg$parse(input, options) {
                     peg$currPos++;
                   } else {
                     s8 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e24); }
                   }
                 }
                 if (s8 !== peg$FAILED) {
@@ -20208,47 +20325,47 @@ function peg$parse(input, options) {
               s5.push(s6);
               s6 = peg$currPos;
               if (input.charCodeAt(peg$currPos) === 39) {
-                s7 = peg$c108;
+                s7 = peg$c99;
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                if (peg$silentFails === 0) { peg$fail(peg$e104); }
               }
               if (s7 !== peg$FAILED) {
                 s8 = [];
-                if (input.substr(peg$currPos, 2) === peg$c109) {
-                  s9 = peg$c109;
+                if (input.substr(peg$currPos, 2) === peg$c100) {
+                  s9 = peg$c100;
                   peg$currPos += 2;
                 } else {
                   s9 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e114); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e105); }
                 }
                 if (s9 === peg$FAILED) {
-                  if (input.substr(peg$currPos, 2) === peg$c110) {
-                    s9 = peg$c110;
+                  if (input.substr(peg$currPos, 2) === peg$c101) {
+                    s9 = peg$c101;
                     peg$currPos += 2;
                   } else {
                     s9 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e115); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e106); }
                   }
                   if (s9 === peg$FAILED) {
-                    if (input.substr(peg$currPos, 2) === peg$c111) {
-                      s9 = peg$c111;
+                    if (input.substr(peg$currPos, 2) === peg$c102) {
+                      s9 = peg$c102;
                       peg$currPos += 2;
                     } else {
                       s9 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e116); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e107); }
                     }
                     if (s9 === peg$FAILED) {
                       s9 = peg$currPos;
                       s10 = peg$currPos;
                       peg$silentFails++;
                       if (input.charCodeAt(peg$currPos) === 39) {
-                        s11 = peg$c108;
+                        s11 = peg$c99;
                         peg$currPos++;
                       } else {
                         s11 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e104); }
                       }
                       peg$silentFails--;
                       if (s11 === peg$FAILED) {
@@ -20263,7 +20380,7 @@ function peg$parse(input, options) {
                           peg$currPos++;
                         } else {
                           s11 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e117); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e108); }
                         }
                         if (s11 === peg$FAILED) {
                           if (input.length > peg$currPos) {
@@ -20271,7 +20388,7 @@ function peg$parse(input, options) {
                             peg$currPos++;
                           } else {
                             s11 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e24); }
                           }
                         }
                         if (s11 !== peg$FAILED) {
@@ -20290,39 +20407,39 @@ function peg$parse(input, options) {
                 }
                 while (s9 !== peg$FAILED) {
                   s8.push(s9);
-                  if (input.substr(peg$currPos, 2) === peg$c109) {
-                    s9 = peg$c109;
+                  if (input.substr(peg$currPos, 2) === peg$c100) {
+                    s9 = peg$c100;
                     peg$currPos += 2;
                   } else {
                     s9 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e114); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e105); }
                   }
                   if (s9 === peg$FAILED) {
-                    if (input.substr(peg$currPos, 2) === peg$c110) {
-                      s9 = peg$c110;
+                    if (input.substr(peg$currPos, 2) === peg$c101) {
+                      s9 = peg$c101;
                       peg$currPos += 2;
                     } else {
                       s9 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e115); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e106); }
                     }
                     if (s9 === peg$FAILED) {
-                      if (input.substr(peg$currPos, 2) === peg$c111) {
-                        s9 = peg$c111;
+                      if (input.substr(peg$currPos, 2) === peg$c102) {
+                        s9 = peg$c102;
                         peg$currPos += 2;
                       } else {
                         s9 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e116); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e107); }
                       }
                       if (s9 === peg$FAILED) {
                         s9 = peg$currPos;
                         s10 = peg$currPos;
                         peg$silentFails++;
                         if (input.charCodeAt(peg$currPos) === 39) {
-                          s11 = peg$c108;
+                          s11 = peg$c99;
                           peg$currPos++;
                         } else {
                           s11 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e104); }
                         }
                         peg$silentFails--;
                         if (s11 === peg$FAILED) {
@@ -20337,7 +20454,7 @@ function peg$parse(input, options) {
                             peg$currPos++;
                           } else {
                             s11 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e117); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e108); }
                           }
                           if (s11 === peg$FAILED) {
                             if (input.length > peg$currPos) {
@@ -20345,7 +20462,7 @@ function peg$parse(input, options) {
                               peg$currPos++;
                             } else {
                               s11 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e24); }
                             }
                           }
                           if (s11 !== peg$FAILED) {
@@ -20364,11 +20481,11 @@ function peg$parse(input, options) {
                   }
                 }
                 if (input.charCodeAt(peg$currPos) === 39) {
-                  s9 = peg$c108;
+                  s9 = peg$c99;
                   peg$currPos++;
                 } else {
                   s9 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e104); }
                 }
                 if (s9 !== peg$FAILED) {
                   s7 = [s7, s8, s9];
@@ -20378,78 +20495,9376 @@ function peg$parse(input, options) {
                   s6 = peg$FAILED;
                 }
               } else {
-                peg$currPos = s6;
-                s6 = peg$FAILED;
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+              if (s6 === peg$FAILED) {
+                s6 = peg$currPos;
+                s7 = peg$currPos;
+                peg$silentFails++;
+                if (input.charCodeAt(peg$currPos) === 59) {
+                  s8 = peg$c0;
+                  peg$currPos++;
+                } else {
+                  s8 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e0); }
+                }
+                peg$silentFails--;
+                if (s8 === peg$FAILED) {
+                  s7 = undefined;
+                } else {
+                  peg$currPos = s7;
+                  s7 = peg$FAILED;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = input.charAt(peg$currPos);
+                  if (peg$r4.test(s8)) {
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e108); }
+                  }
+                  if (s8 === peg$FAILED) {
+                    if (input.length > peg$currPos) {
+                      s8 = input.charAt(peg$currPos);
+                      peg$currPos++;
+                    } else {
+                      s8 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e24); }
+                    }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s7 = [s7, s8];
+                    s6 = s7;
+                  } else {
+                    peg$currPos = s6;
+                    s6 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s6;
+                  s6 = peg$FAILED;
+                }
+              }
+            }
+            s3 = [s3, s4, s5];
+            s2 = s3;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s1 = input.substring(s1, peg$currPos);
+        } else {
+          s1 = s2;
+        }
+        if (s1 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$f114(s1);
+        }
+        s0 = s1;
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseUndropStatement() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
+
+    const key = peg$currPos * 508 + 79;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 6);
+    if (s1.toLowerCase() === peg$c103) {
+      peg$currPos += (6);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e109); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = input.substr(peg$currPos, 5);
+        if (s4.toLowerCase() === peg$c23) {
+          peg$currPos += (5);
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e27); }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          peg$silentFails++;
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s6 === peg$FAILED) {
+            s5 = undefined;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = peg$currPos;
+            s7 = peg$parse_();
+            s8 = input.substr(peg$currPos, 2);
+            if (s8.toLowerCase() === peg$c29) {
+              peg$currPos += (2);
+            } else {
+              s8 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
+            }
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              peg$silentFails++;
+              s10 = input.charAt(peg$currPos);
+              if (peg$r0.test(s10)) {
+                peg$currPos++;
+              } else {
+                s10 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s10 === peg$FAILED) {
+                s9 = undefined;
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 !== peg$FAILED) {
+                s10 = peg$parse_();
+                s11 = input.substr(peg$currPos, 3);
+                if (s11.toLowerCase() === peg$c30) {
+                  peg$currPos += (3);
+                } else {
+                  s11 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
+                }
+                if (s11 !== peg$FAILED) {
+                  s12 = peg$currPos;
+                  peg$silentFails++;
+                  s13 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s13)) {
+                    peg$currPos++;
+                  } else {
+                    s13 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s13 === peg$FAILED) {
+                    s12 = undefined;
+                  } else {
+                    peg$currPos = s12;
+                    s12 = peg$FAILED;
+                  }
+                  if (s12 !== peg$FAILED) {
+                    s13 = peg$parse_();
+                    s14 = input.substr(peg$currPos, 6);
+                    if (s14.toLowerCase() === peg$c31) {
+                      peg$currPos += (6);
+                    } else {
+                      s14 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
+                    }
+                    if (s14 !== peg$FAILED) {
+                      s15 = peg$currPos;
+                      peg$silentFails++;
+                      s16 = input.charAt(peg$currPos);
+                      if (peg$r0.test(s16)) {
+                        peg$currPos++;
+                      } else {
+                        s16 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                      }
+                      peg$silentFails--;
+                      if (s16 === peg$FAILED) {
+                        s15 = undefined;
+                      } else {
+                        peg$currPos = s15;
+                        s15 = peg$FAILED;
+                      }
+                      if (s15 !== peg$FAILED) {
+                        s7 = [s7, s8, s9, s10, s11, s12, s13, s14, s15];
+                        s6 = s7;
+                      } else {
+                        peg$currPos = s6;
+                        s6 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s6;
+                      s6 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s6;
+                    s6 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s6;
+                  s6 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+            if (s6 === peg$FAILED) {
+              s6 = null;
+            }
+            s7 = peg$parse_();
+            s8 = peg$parseTableRef();
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              s10 = peg$parse_();
+              s11 = input.substr(peg$currPos, 4);
+              if (s11.toLowerCase() === peg$c104) {
+                peg$currPos += (4);
+              } else {
+                s11 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e110); }
+              }
+              if (s11 !== peg$FAILED) {
+                s12 = peg$currPos;
+                peg$silentFails++;
+                s13 = input.charAt(peg$currPos);
+                if (peg$r0.test(s13)) {
+                  peg$currPos++;
+                } else {
+                  s13 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s13 === peg$FAILED) {
+                  s12 = undefined;
+                } else {
+                  peg$currPos = s12;
+                  s12 = peg$FAILED;
+                }
+                if (s12 !== peg$FAILED) {
+                  s13 = peg$parse_();
+                  s14 = peg$parseStringLiteral();
+                  if (s14 !== peg$FAILED) {
+                    s10 = [s10, s11, s12, s13, s14];
+                    s9 = s10;
+                  } else {
+                    peg$currPos = s9;
+                    s9 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s9;
+                  s9 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 === peg$FAILED) {
+                s9 = null;
+              }
+              s10 = peg$currPos;
+              s11 = peg$parse_();
+              s12 = peg$parseOnClusterClause();
+              if (s12 !== peg$FAILED) {
+                s11 = [s11, s12];
+                s10 = s11;
+              } else {
+                peg$currPos = s10;
+                s10 = peg$FAILED;
+              }
+              if (s10 === peg$FAILED) {
+                s10 = null;
+              }
+              s11 = peg$currPos;
+              s12 = peg$parse_();
+              s13 = peg$parseFormatClause();
+              if (s13 !== peg$FAILED) {
+                s12 = [s12, s13];
+                s11 = s12;
+              } else {
+                peg$currPos = s11;
+                s11 = peg$FAILED;
+              }
+              if (s11 === peg$FAILED) {
+                s11 = null;
+              }
+              peg$savedPos = s0;
+              s0 = peg$f115(s6, s8, s9, s10, s11);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseBackupStatement() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
+
+    const key = peg$currPos * 508 + 80;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 6);
+    if (s1.toLowerCase() === peg$c105) {
+      peg$currPos += (6);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e111); }
+    }
+    if (s1 === peg$FAILED) {
+      s1 = input.substr(peg$currPos, 7);
+      if (s1.toLowerCase() === peg$c106) {
+        peg$currPos += (7);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e112); }
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = peg$parseBackupElementList();
+        if (s4 !== peg$FAILED) {
+          s5 = peg$parse_();
+          s6 = input.substr(peg$currPos, 2);
+          if (s6.toLowerCase() === peg$c11) {
+            peg$currPos += (2);
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e13); }
+          }
+          if (s6 === peg$FAILED) {
+            s6 = input.substr(peg$currPos, 4);
+            if (s6.toLowerCase() === peg$c73) {
+              peg$currPos += (4);
+            } else {
+              s6 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e78); }
+            }
+          }
+          if (s6 !== peg$FAILED) {
+            s7 = peg$currPos;
+            peg$silentFails++;
+            s8 = input.charAt(peg$currPos);
+            if (peg$r0.test(s8)) {
+              peg$currPos++;
+            } else {
+              s8 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s8 === peg$FAILED) {
+              s7 = undefined;
+            } else {
+              peg$currPos = s7;
+              s7 = peg$FAILED;
+            }
+            if (s7 !== peg$FAILED) {
+              s8 = peg$parse_();
+              s9 = peg$parseBackupDestination();
+              if (s9 !== peg$FAILED) {
+                s10 = peg$currPos;
+                s11 = peg$parse_();
+                s12 = peg$parseOnClusterClause();
+                if (s12 !== peg$FAILED) {
+                  s11 = [s11, s12];
+                  s10 = s11;
+                } else {
+                  peg$currPos = s10;
+                  s10 = peg$FAILED;
+                }
+                if (s10 === peg$FAILED) {
+                  s10 = null;
+                }
+                s11 = peg$currPos;
+                s12 = peg$parse_();
+                s13 = peg$parseSettingsClause();
+                if (s13 !== peg$FAILED) {
+                  s12 = [s12, s13];
+                  s11 = s12;
+                } else {
+                  peg$currPos = s11;
+                  s11 = peg$FAILED;
+                }
+                if (s11 === peg$FAILED) {
+                  s11 = null;
+                }
+                s12 = peg$currPos;
+                s13 = peg$parse_();
+                s14 = input.substr(peg$currPos, 4);
+                if (s14.toLowerCase() === peg$c96) {
+                  peg$currPos += (4);
+                } else {
+                  s14 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e101); }
+                }
+                if (s14 === peg$FAILED) {
+                  s14 = input.substr(peg$currPos, 5);
+                  if (s14.toLowerCase() === peg$c107) {
+                    peg$currPos += (5);
+                  } else {
+                    s14 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                  }
+                }
+                if (s14 !== peg$FAILED) {
+                  s15 = peg$currPos;
+                  peg$silentFails++;
+                  s16 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s16)) {
+                    peg$currPos++;
+                  } else {
+                    s16 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s16 === peg$FAILED) {
+                    s15 = undefined;
+                  } else {
+                    peg$currPos = s15;
+                    s15 = peg$FAILED;
+                  }
+                  if (s15 !== peg$FAILED) {
+                    s13 = [s13, s14, s15];
+                    s12 = s13;
+                  } else {
+                    peg$currPos = s12;
+                    s12 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s12;
+                  s12 = peg$FAILED;
+                }
+                if (s12 === peg$FAILED) {
+                  s12 = null;
+                }
+                s13 = peg$currPos;
+                s14 = peg$parse_();
+                s15 = peg$parseFormatClause();
+                if (s15 !== peg$FAILED) {
+                  s14 = [s14, s15];
+                  s13 = s14;
+                } else {
+                  peg$currPos = s13;
+                  s13 = peg$FAILED;
+                }
+                if (s13 === peg$FAILED) {
+                  s13 = null;
+                }
+                peg$savedPos = s0;
+                s0 = peg$f116(s1, s4, s9, s10, s11, s12, s13);
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseBackupElementList() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
+
+    const key = peg$currPos * 508 + 81;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 3);
+    if (s1.toLowerCase() === peg$c12) {
+      peg$currPos += (3);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e14); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        s5 = input.substr(peg$currPos, 9);
+        if (s5.toLowerCase() === peg$c108) {
+          peg$currPos += (9);
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e114); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$currPos;
+          peg$silentFails++;
+          s7 = input.charAt(peg$currPos);
+          if (peg$r0.test(s7)) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s7 === peg$FAILED) {
+            s6 = undefined;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            s4 = [s4, s5, s6];
+            s3 = s4;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        s4 = peg$currPos;
+        s5 = peg$parse_();
+        s6 = input.substr(peg$currPos, 6);
+        if (s6.toLowerCase() === peg$c13) {
+          peg$currPos += (6);
+        } else {
+          s6 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e15); }
+        }
+        if (s6 !== peg$FAILED) {
+          s7 = peg$currPos;
+          peg$silentFails++;
+          s8 = input.charAt(peg$currPos);
+          if (peg$r0.test(s8)) {
+            peg$currPos++;
+          } else {
+            s8 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s8 === peg$FAILED) {
+            s7 = undefined;
+          } else {
+            peg$currPos = s7;
+            s7 = peg$FAILED;
+          }
+          if (s7 !== peg$FAILED) {
+            s8 = peg$parse_();
+            s9 = input.substr(peg$currPos, 9);
+            if (s9.toLowerCase() === peg$c108) {
+              peg$currPos += (9);
+            } else {
+              s9 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e114); }
+            }
+            if (s9 !== peg$FAILED) {
+              s10 = peg$currPos;
+              peg$silentFails++;
+              s11 = input.charAt(peg$currPos);
+              if (peg$r0.test(s11)) {
+                peg$currPos++;
+              } else {
+                s11 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s11 === peg$FAILED) {
+                s10 = undefined;
+              } else {
+                peg$currPos = s10;
+                s10 = peg$FAILED;
+              }
+              if (s10 !== peg$FAILED) {
+                s11 = peg$parse_();
+                s12 = peg$parseAliasNameList();
+                if (s12 !== peg$FAILED) {
+                  s5 = [s5, s6, s7, s8, s9, s10, s11, s12];
+                  s4 = s5;
+                } else {
+                  peg$currPos = s4;
+                  s4 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s4;
+                s4 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s4;
+              s4 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+        if (s4 === peg$FAILED) {
+          s4 = null;
+        }
+        s5 = peg$currPos;
+        s6 = peg$parse_();
+        s7 = input.substr(peg$currPos, 6);
+        if (s7.toLowerCase() === peg$c13) {
+          peg$currPos += (6);
+        } else {
+          s7 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e15); }
+        }
+        if (s7 !== peg$FAILED) {
+          s8 = peg$currPos;
+          peg$silentFails++;
+          s9 = input.charAt(peg$currPos);
+          if (peg$r0.test(s9)) {
+            peg$currPos++;
+          } else {
+            s9 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s9 === peg$FAILED) {
+            s8 = undefined;
+          } else {
+            peg$currPos = s8;
+            s8 = peg$FAILED;
+          }
+          if (s8 !== peg$FAILED) {
+            s9 = peg$parse_();
+            s10 = input.substr(peg$currPos, 6);
+            if (s10.toLowerCase() === peg$c109) {
+              peg$currPos += (6);
+            } else {
+              s10 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e115); }
+            }
+            if (s10 !== peg$FAILED) {
+              s11 = peg$currPos;
+              peg$silentFails++;
+              s12 = input.charAt(peg$currPos);
+              if (peg$r0.test(s12)) {
+                peg$currPos++;
+              } else {
+                s12 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s12 === peg$FAILED) {
+                s11 = undefined;
+              } else {
+                peg$currPos = s11;
+                s11 = peg$FAILED;
+              }
+              if (s11 !== peg$FAILED) {
+                s12 = peg$parse_();
+                s13 = peg$parseBackupTableRefList();
+                if (s13 !== peg$FAILED) {
+                  s6 = [s6, s7, s8, s9, s10, s11, s12, s13];
+                  s5 = s6;
+                } else {
+                  peg$currPos = s5;
+                  s5 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s5;
+                s5 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s5;
+              s5 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s5;
+          s5 = peg$FAILED;
+        }
+        if (s5 === peg$FAILED) {
+          s5 = null;
+        }
+        peg$savedPos = s0;
+        s0 = peg$f117(s4, s5);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseBackupElement();
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (input.charCodeAt(peg$currPos) === 44) {
+          s5 = peg$c24;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parse_();
+          s7 = peg$parseBackupElement();
+          if (s7 !== peg$FAILED) {
+            s4 = [s4, s5, s6, s7];
+            s3 = s4;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$currPos;
+          s4 = peg$parse_();
+          if (input.charCodeAt(peg$currPos) === 44) {
+            s5 = peg$c24;
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parse_();
+            s7 = peg$parseBackupElement();
+            if (s7 !== peg$FAILED) {
+              s4 = [s4, s5, s6, s7];
+              s3 = s4;
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        }
+        peg$savedPos = s0;
+        s0 = peg$f118(s1, s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseBackupElement() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14;
+
+    const key = peg$currPos * 508 + 82;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 9);
+    if (s1.toLowerCase() === peg$c22) {
+      peg$currPos += (9);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = input.substr(peg$currPos, 5);
+        if (s4.toLowerCase() === peg$c23) {
+          peg$currPos += (5);
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e27); }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          peg$silentFails++;
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s6 === peg$FAILED) {
+            s5 = undefined;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parse_();
+            s7 = peg$parseTableRef();
+            if (s7 !== peg$FAILED) {
+              s8 = peg$parseBackupAsTable();
+              if (s8 === peg$FAILED) {
+                s8 = null;
+              }
+              peg$savedPos = s0;
+              s0 = peg$f119(s7, s8);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = input.substr(peg$currPos, 5);
+      if (s1.toLowerCase() === peg$c23) {
+        peg$currPos += (5);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e27); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r0.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parse_();
+          s4 = peg$parseTableRef();
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseBackupAsTable();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            s6 = peg$currPos;
+            s7 = peg$parse_();
+            s8 = peg$parseBackupPartitions();
+            if (s8 !== peg$FAILED) {
+              s7 = [s7, s8];
+              s6 = s7;
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+            if (s6 === peg$FAILED) {
+              s6 = null;
+            }
+            s7 = peg$currPos;
+            s8 = peg$parse_();
+            s9 = peg$parseBackupExceptColumns();
+            if (s9 !== peg$FAILED) {
+              s8 = [s8, s9];
+              s7 = s8;
+            } else {
+              peg$currPos = s7;
+              s7 = peg$FAILED;
+            }
+            if (s7 === peg$FAILED) {
+              s7 = null;
+            }
+            peg$savedPos = s0;
+            s0 = peg$f120(s4, s5, s6, s7);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = input.substr(peg$currPos, 10);
+        if (s1.toLowerCase() === peg$c110) {
+          peg$currPos += (10);
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e116); }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$currPos;
+          peg$silentFails++;
+          s3 = input.charAt(peg$currPos);
+          if (peg$r0.test(s3)) {
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s3 === peg$FAILED) {
+            s2 = undefined;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+          if (s2 !== peg$FAILED) {
+            s3 = peg$parse_();
+            s4 = peg$parseTableRef();
+            if (s4 !== peg$FAILED) {
+              s5 = peg$parseBackupAsTable();
+              if (s5 === peg$FAILED) {
+                s5 = null;
+              }
+              peg$savedPos = s0;
+              s0 = peg$f121(s4, s5);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = input.substr(peg$currPos, 4);
+          if (s1.toLowerCase() === peg$c111) {
+            peg$currPos += (4);
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e117); }
+          }
+          if (s1 !== peg$FAILED) {
+            s2 = peg$currPos;
+            peg$silentFails++;
+            s3 = input.charAt(peg$currPos);
+            if (peg$r0.test(s3)) {
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s3 === peg$FAILED) {
+              s2 = undefined;
+            } else {
+              peg$currPos = s2;
+              s2 = peg$FAILED;
+            }
+            if (s2 !== peg$FAILED) {
+              s3 = peg$parse_();
+              s4 = peg$parseTableRef();
+              if (s4 !== peg$FAILED) {
+                s5 = peg$parseBackupAsTable();
+                if (s5 === peg$FAILED) {
+                  s5 = null;
+                }
+                peg$savedPos = s0;
+                s0 = peg$f122(s4, s5);
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            s1 = input.substr(peg$currPos, 8);
+            if (s1.toLowerCase() === peg$c112) {
+              peg$currPos += (8);
+            } else {
+              s1 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e118); }
+            }
+            if (s1 !== peg$FAILED) {
+              s2 = peg$currPos;
+              peg$silentFails++;
+              s3 = input.charAt(peg$currPos);
+              if (peg$r0.test(s3)) {
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s3 === peg$FAILED) {
+                s2 = undefined;
+              } else {
+                peg$currPos = s2;
+                s2 = peg$FAILED;
+              }
+              if (s2 !== peg$FAILED) {
+                s3 = peg$parse_();
+                s4 = peg$parseAliasName();
+                if (s4 !== peg$FAILED) {
+                  s5 = peg$currPos;
+                  s6 = peg$parse_();
+                  s7 = peg$parseKW_AS();
+                  if (s7 !== peg$FAILED) {
+                    s8 = peg$parse_();
+                    s9 = peg$parseAliasName();
+                    if (s9 !== peg$FAILED) {
+                      s6 = [s6, s7, s8, s9];
+                      s5 = s6;
+                    } else {
+                      peg$currPos = s5;
+                      s5 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s5;
+                    s5 = peg$FAILED;
+                  }
+                  if (s5 === peg$FAILED) {
+                    s5 = null;
+                  }
+                  s6 = peg$currPos;
+                  s7 = peg$parse_();
+                  s8 = input.substr(peg$currPos, 6);
+                  if (s8.toLowerCase() === peg$c13) {
+                    peg$currPos += (6);
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e15); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$currPos;
+                    peg$silentFails++;
+                    s10 = input.charAt(peg$currPos);
+                    if (peg$r0.test(s10)) {
+                      peg$currPos++;
+                    } else {
+                      s10 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                    }
+                    peg$silentFails--;
+                    if (s10 === peg$FAILED) {
+                      s9 = undefined;
+                    } else {
+                      peg$currPos = s9;
+                      s9 = peg$FAILED;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      s10 = peg$parse_();
+                      s11 = input.substr(peg$currPos, 6);
+                      if (s11.toLowerCase() === peg$c109) {
+                        peg$currPos += (6);
+                      } else {
+                        s11 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e115); }
+                      }
+                      if (s11 !== peg$FAILED) {
+                        s12 = peg$currPos;
+                        peg$silentFails++;
+                        s13 = input.charAt(peg$currPos);
+                        if (peg$r0.test(s13)) {
+                          peg$currPos++;
+                        } else {
+                          s13 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                        }
+                        peg$silentFails--;
+                        if (s13 === peg$FAILED) {
+                          s12 = undefined;
+                        } else {
+                          peg$currPos = s12;
+                          s12 = peg$FAILED;
+                        }
+                        if (s12 !== peg$FAILED) {
+                          s13 = peg$parse_();
+                          s14 = peg$parseAliasNameList();
+                          if (s14 !== peg$FAILED) {
+                            s7 = [s7, s8, s9, s10, s11, s12, s13, s14];
+                            s6 = s7;
+                          } else {
+                            peg$currPos = s6;
+                            s6 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s6;
+                          s6 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s6;
+                        s6 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s6;
+                      s6 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s6;
+                    s6 = peg$FAILED;
+                  }
+                  if (s6 === peg$FAILED) {
+                    s6 = null;
+                  }
+                  peg$savedPos = s0;
+                  s0 = peg$f123(s4, s5, s6);
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+            if (s0 === peg$FAILED) {
+              s0 = peg$currPos;
+              s1 = input.substr(peg$currPos, 8);
+              if (s1.toLowerCase() === peg$c113) {
+                peg$currPos += (8);
+              } else {
+                s1 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e119); }
+              }
+              if (s1 !== peg$FAILED) {
+                s2 = peg$currPos;
+                peg$silentFails++;
+                s3 = input.charAt(peg$currPos);
+                if (peg$r0.test(s3)) {
+                  peg$currPos++;
+                } else {
+                  s3 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s3 === peg$FAILED) {
+                  s2 = undefined;
+                } else {
+                  peg$currPos = s2;
+                  s2 = peg$FAILED;
+                }
+                if (s2 !== peg$FAILED) {
+                  s3 = peg$parse_();
+                  s4 = peg$parseAliasName();
+                  if (s4 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s0 = peg$f124(s4);
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+              if (s0 === peg$FAILED) {
+                s0 = peg$currPos;
+                s1 = input.substr(peg$currPos, 5);
+                if (s1.toLowerCase() === peg$c114) {
+                  peg$currPos += (5);
+                } else {
+                  s1 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e120); }
+                }
+                if (s1 !== peg$FAILED) {
+                  s2 = peg$currPos;
+                  peg$silentFails++;
+                  s3 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s3)) {
+                    peg$currPos++;
+                  } else {
+                    s3 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s3 === peg$FAILED) {
+                    s2 = undefined;
+                  } else {
+                    peg$currPos = s2;
+                    s2 = peg$FAILED;
+                  }
+                  if (s2 !== peg$FAILED) {
+                    s3 = peg$parse_();
+                    s4 = input.substr(peg$currPos, 10);
+                    if (s4.toLowerCase() === peg$c115) {
+                      peg$currPos += (10);
+                    } else {
+                      s4 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e121); }
+                    }
+                    if (s4 !== peg$FAILED) {
+                      s5 = peg$currPos;
+                      peg$silentFails++;
+                      s6 = input.charAt(peg$currPos);
+                      if (peg$r0.test(s6)) {
+                        peg$currPos++;
+                      } else {
+                        s6 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                      }
+                      peg$silentFails--;
+                      if (s6 === peg$FAILED) {
+                        s5 = undefined;
+                      } else {
+                        peg$currPos = s5;
+                        s5 = peg$FAILED;
+                      }
+                      if (s5 !== peg$FAILED) {
+                        s6 = peg$parse_();
+                        s7 = peg$parseAliasName();
+                        if (s7 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s0 = peg$f125(s7);
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseBackupAsTable() {
+    let s0, s1, s2, s3, s4;
+
+    const key = peg$currPos * 508 + 83;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parse_();
+    s2 = peg$parseKW_AS();
+    if (s2 !== peg$FAILED) {
+      s3 = peg$parse_();
+      s4 = peg$parseTableRef();
+      if (s4 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f126(s4);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseBackupPartitions() {
+    let s0, s1, s2, s3, s4;
+
+    const key = peg$currPos * 508 + 84;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 10);
+    if (s1.toLowerCase() === peg$c116) {
+      peg$currPos += (10);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e122); }
+    }
+    if (s1 === peg$FAILED) {
+      s1 = input.substr(peg$currPos, 9);
+      if (s1.toLowerCase() === peg$c70) {
+        peg$currPos += (9);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e75); }
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = peg$parseExpressionList();
+        if (s4 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f127(s4);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseBackupExceptColumns() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    const key = peg$currPos * 508 + 85;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 6);
+    if (s1.toLowerCase() === peg$c13) {
+      peg$currPos += (6);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e15); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = input.substr(peg$currPos, 7);
+        if (s4.toLowerCase() === peg$c117) {
+          peg$currPos += (7);
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e123); }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          peg$silentFails++;
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s6 === peg$FAILED) {
+            s5 = undefined;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parse_();
+            if (input.charCodeAt(peg$currPos) === 40) {
+              s7 = peg$c25;
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+            }
+            if (s7 !== peg$FAILED) {
+              s8 = peg$parse_();
+              s9 = peg$parseAliasNameList();
+              if (s9 !== peg$FAILED) {
+                s10 = peg$parse_();
+                if (input.charCodeAt(peg$currPos) === 41) {
+                  s11 = peg$c26;
+                  peg$currPos++;
+                } else {
+                  s11 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                }
+                if (s11 !== peg$FAILED) {
+                  peg$savedPos = s0;
+                  s0 = peg$f128(s9);
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = input.substr(peg$currPos, 6);
+      if (s1.toLowerCase() === peg$c13) {
+        peg$currPos += (6);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e15); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r0.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parse_();
+          s4 = input.substr(peg$currPos, 7);
+          if (s4.toLowerCase() === peg$c117) {
+            peg$currPos += (7);
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e123); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$currPos;
+            peg$silentFails++;
+            s6 = input.charAt(peg$currPos);
+            if (peg$r0.test(s6)) {
+              peg$currPos++;
+            } else {
+              s6 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s6 === peg$FAILED) {
+              s5 = undefined;
+            } else {
+              peg$currPos = s5;
+              s5 = peg$FAILED;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parse_();
+              s7 = peg$parseAliasNameList();
+              if (s7 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s0 = peg$f129(s7);
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseBackupTableRefList() {
+    let s0, s1, s2, s3, s4, s5, s6, s7;
+
+    const key = peg$currPos * 508 + 86;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parseTableRef();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$currPos;
+      s4 = peg$parse_();
+      if (input.charCodeAt(peg$currPos) === 44) {
+        s5 = peg$c24;
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
+      }
+      if (s5 !== peg$FAILED) {
+        s6 = peg$parse_();
+        s7 = peg$parseTableRef();
+        if (s7 !== peg$FAILED) {
+          s4 = [s4, s5, s6, s7];
+          s3 = s4;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (input.charCodeAt(peg$currPos) === 44) {
+          s5 = peg$c24;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parse_();
+          s7 = peg$parseTableRef();
+          if (s7 !== peg$FAILED) {
+            s4 = [s4, s5, s6, s7];
+            s3 = s4;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f130(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseBackupDestination() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8;
+
+    const key = peg$currPos * 508 + 87;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parseAliasName();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = peg$parse_();
+      if (input.charCodeAt(peg$currPos) === 40) {
+        s4 = peg$c25;
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
+      }
+      if (s4 !== peg$FAILED) {
+        s5 = peg$parse_();
+        s6 = peg$parseExpressionList();
+        if (s6 === peg$FAILED) {
+          s6 = null;
+        }
+        s7 = peg$parse_();
+        if (input.charCodeAt(peg$currPos) === 41) {
+          s8 = peg$c26;
+          peg$currPos++;
+        } else {
+          s8 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
+        }
+        if (s8 !== peg$FAILED) {
+          s3 = [s3, s4, s5, s6, s7, s8];
+          s2 = s3;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      peg$savedPos = s0;
+      s0 = peg$f131(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseAliasNameList() {
+    let s0, s1, s2, s3, s4, s5, s6, s7;
+
+    const key = peg$currPos * 508 + 88;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parseAliasName();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$currPos;
+      s4 = peg$parse_();
+      if (input.charCodeAt(peg$currPos) === 44) {
+        s5 = peg$c24;
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
+      }
+      if (s5 !== peg$FAILED) {
+        s6 = peg$parse_();
+        s7 = peg$parseAliasName();
+        if (s7 !== peg$FAILED) {
+          s4 = [s4, s5, s6, s7];
+          s3 = s4;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (input.charCodeAt(peg$currPos) === 44) {
+          s5 = peg$c24;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parse_();
+          s7 = peg$parseAliasName();
+          if (s7 !== peg$FAILED) {
+            s4 = [s4, s5, s6, s7];
+            s3 = s4;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f132(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGrantStatement() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23;
+
+    const key = peg$currPos * 508 + 89;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 5);
+    if (s1.toLowerCase() === peg$c118) {
+      peg$currPos += (5);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e124); }
+    }
+    if (s1 === peg$FAILED) {
+      s1 = input.substr(peg$currPos, 6);
+      if (s1.toLowerCase() === peg$c119) {
+        peg$currPos += (6);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e125); }
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        s5 = input.substr(peg$currPos, 5);
+        if (s5.toLowerCase() === peg$c118) {
+          peg$currPos += (5);
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e124); }
+        }
+        if (s5 === peg$FAILED) {
+          s5 = input.substr(peg$currPos, 5);
+          if (s5.toLowerCase() === peg$c120) {
+            peg$currPos += (5);
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e126); }
+          }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$currPos;
+          peg$silentFails++;
+          s7 = input.charAt(peg$currPos);
+          if (peg$r0.test(s7)) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s7 === peg$FAILED) {
+            s6 = undefined;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            s7 = peg$parse_();
+            s8 = input.substr(peg$currPos, 6);
+            if (s8.toLowerCase() === peg$c121) {
+              peg$currPos += (6);
+            } else {
+              s8 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e127); }
+            }
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              peg$silentFails++;
+              s10 = input.charAt(peg$currPos);
+              if (peg$r0.test(s10)) {
+                peg$currPos++;
+              } else {
+                s10 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s10 === peg$FAILED) {
+                s9 = undefined;
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 !== peg$FAILED) {
+                s10 = peg$parse_();
+                s11 = input.substr(peg$currPos, 3);
+                if (s11.toLowerCase() === peg$c122) {
+                  peg$currPos += (3);
+                } else {
+                  s11 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e128); }
+                }
+                if (s11 !== peg$FAILED) {
+                  s12 = peg$currPos;
+                  peg$silentFails++;
+                  s13 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s13)) {
+                    peg$currPos++;
+                  } else {
+                    s13 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s13 === peg$FAILED) {
+                    s12 = undefined;
+                  } else {
+                    peg$currPos = s12;
+                    s12 = peg$FAILED;
+                  }
+                  if (s12 !== peg$FAILED) {
+                    s4 = [s4, s5, s6, s7, s8, s9, s10, s11, s12];
+                    s3 = s4;
+                  } else {
+                    peg$currPos = s3;
+                    s3 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s3;
+                  s3 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        s4 = peg$currPos;
+        s5 = peg$parse_();
+        s6 = peg$parseOnClusterClause();
+        if (s6 !== peg$FAILED) {
+          s5 = [s5, s6];
+          s4 = s5;
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+        if (s4 === peg$FAILED) {
+          s4 = null;
+        }
+        s5 = peg$parse_();
+        s6 = peg$currPos;
+        s7 = peg$parseGrantElementList();
+        if (s7 !== peg$FAILED) {
+          peg$savedPos = s6;
+          s7 = peg$f133(s1, s3, s4, s7);
+        }
+        s6 = s7;
+        if (s6 === peg$FAILED) {
+          s6 = peg$currPos;
+          s7 = peg$parseGrantRoleList();
+          if (s7 !== peg$FAILED) {
+            peg$savedPos = s6;
+            s7 = peg$f134(s1, s3, s4, s7);
+          }
+          s6 = s7;
+        }
+        if (s6 !== peg$FAILED) {
+          s7 = peg$parse_();
+          s8 = input.substr(peg$currPos, 2);
+          if (s8.toLowerCase() === peg$c11) {
+            peg$currPos += (2);
+          } else {
+            s8 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e13); }
+          }
+          if (s8 === peg$FAILED) {
+            s8 = input.substr(peg$currPos, 4);
+            if (s8.toLowerCase() === peg$c73) {
+              peg$currPos += (4);
+            } else {
+              s8 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e78); }
+            }
+          }
+          if (s8 !== peg$FAILED) {
+            s9 = peg$currPos;
+            peg$silentFails++;
+            s10 = input.charAt(peg$currPos);
+            if (peg$r0.test(s10)) {
+              peg$currPos++;
+            } else {
+              s10 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s10 === peg$FAILED) {
+              s9 = undefined;
+            } else {
+              peg$currPos = s9;
+              s9 = peg$FAILED;
+            }
+            if (s9 !== peg$FAILED) {
+              s10 = peg$parse_();
+              s11 = peg$parseGranteeList();
+              if (s11 !== peg$FAILED) {
+                s12 = [];
+                s13 = peg$currPos;
+                s14 = peg$parse_();
+                s15 = input.substr(peg$currPos, 4);
+                if (s15.toLowerCase() === peg$c57) {
+                  peg$currPos += (4);
+                } else {
+                  s15 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e62); }
+                }
+                if (s15 !== peg$FAILED) {
+                  s16 = peg$currPos;
+                  peg$silentFails++;
+                  s17 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s17)) {
+                    peg$currPos++;
+                  } else {
+                    s17 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s17 === peg$FAILED) {
+                    s16 = undefined;
+                  } else {
+                    peg$currPos = s16;
+                    s16 = peg$FAILED;
+                  }
+                  if (s16 !== peg$FAILED) {
+                    s17 = peg$parse_();
+                    s18 = input.substr(peg$currPos, 5);
+                    if (s18.toLowerCase() === peg$c118) {
+                      peg$currPos += (5);
+                    } else {
+                      s18 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e124); }
+                    }
+                    if (s18 === peg$FAILED) {
+                      s18 = input.substr(peg$currPos, 5);
+                      if (s18.toLowerCase() === peg$c120) {
+                        peg$currPos += (5);
+                      } else {
+                        s18 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e126); }
+                      }
+                      if (s18 === peg$FAILED) {
+                        s18 = input.substr(peg$currPos, 7);
+                        if (s18.toLowerCase() === peg$c74) {
+                          peg$currPos += (7);
+                        } else {
+                          s18 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$e79); }
+                        }
+                      }
+                    }
+                    if (s18 !== peg$FAILED) {
+                      s19 = peg$currPos;
+                      peg$silentFails++;
+                      s20 = input.charAt(peg$currPos);
+                      if (peg$r0.test(s20)) {
+                        peg$currPos++;
+                      } else {
+                        s20 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                      }
+                      peg$silentFails--;
+                      if (s20 === peg$FAILED) {
+                        s19 = undefined;
+                      } else {
+                        peg$currPos = s19;
+                        s19 = peg$FAILED;
+                      }
+                      if (s19 !== peg$FAILED) {
+                        s20 = peg$parse_();
+                        s21 = input.substr(peg$currPos, 6);
+                        if (s21.toLowerCase() === peg$c121) {
+                          peg$currPos += (6);
+                        } else {
+                          s21 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$e127); }
+                        }
+                        if (s21 !== peg$FAILED) {
+                          s22 = peg$currPos;
+                          peg$silentFails++;
+                          s23 = input.charAt(peg$currPos);
+                          if (peg$r0.test(s23)) {
+                            peg$currPos++;
+                          } else {
+                            s23 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                          }
+                          peg$silentFails--;
+                          if (s23 === peg$FAILED) {
+                            s22 = undefined;
+                          } else {
+                            peg$currPos = s22;
+                            s22 = peg$FAILED;
+                          }
+                          if (s22 !== peg$FAILED) {
+                            s14 = [s14, s15, s16, s17, s18, s19, s20, s21, s22];
+                            s13 = s14;
+                          } else {
+                            peg$currPos = s13;
+                            s13 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s13;
+                          s13 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s13;
+                        s13 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s13;
+                      s13 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s13;
+                    s13 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s13;
+                  s13 = peg$FAILED;
+                }
+                while (s13 !== peg$FAILED) {
+                  s12.push(s13);
+                  s13 = peg$currPos;
+                  s14 = peg$parse_();
+                  s15 = input.substr(peg$currPos, 4);
+                  if (s15.toLowerCase() === peg$c57) {
+                    peg$currPos += (4);
+                  } else {
+                    s15 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e62); }
+                  }
+                  if (s15 !== peg$FAILED) {
+                    s16 = peg$currPos;
+                    peg$silentFails++;
+                    s17 = input.charAt(peg$currPos);
+                    if (peg$r0.test(s17)) {
+                      peg$currPos++;
+                    } else {
+                      s17 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                    }
+                    peg$silentFails--;
+                    if (s17 === peg$FAILED) {
+                      s16 = undefined;
+                    } else {
+                      peg$currPos = s16;
+                      s16 = peg$FAILED;
+                    }
+                    if (s16 !== peg$FAILED) {
+                      s17 = peg$parse_();
+                      s18 = input.substr(peg$currPos, 5);
+                      if (s18.toLowerCase() === peg$c118) {
+                        peg$currPos += (5);
+                      } else {
+                        s18 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e124); }
+                      }
+                      if (s18 === peg$FAILED) {
+                        s18 = input.substr(peg$currPos, 5);
+                        if (s18.toLowerCase() === peg$c120) {
+                          peg$currPos += (5);
+                        } else {
+                          s18 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$e126); }
+                        }
+                        if (s18 === peg$FAILED) {
+                          s18 = input.substr(peg$currPos, 7);
+                          if (s18.toLowerCase() === peg$c74) {
+                            peg$currPos += (7);
+                          } else {
+                            s18 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$e79); }
+                          }
+                        }
+                      }
+                      if (s18 !== peg$FAILED) {
+                        s19 = peg$currPos;
+                        peg$silentFails++;
+                        s20 = input.charAt(peg$currPos);
+                        if (peg$r0.test(s20)) {
+                          peg$currPos++;
+                        } else {
+                          s20 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                        }
+                        peg$silentFails--;
+                        if (s20 === peg$FAILED) {
+                          s19 = undefined;
+                        } else {
+                          peg$currPos = s19;
+                          s19 = peg$FAILED;
+                        }
+                        if (s19 !== peg$FAILED) {
+                          s20 = peg$parse_();
+                          s21 = input.substr(peg$currPos, 6);
+                          if (s21.toLowerCase() === peg$c121) {
+                            peg$currPos += (6);
+                          } else {
+                            s21 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$e127); }
+                          }
+                          if (s21 !== peg$FAILED) {
+                            s22 = peg$currPos;
+                            peg$silentFails++;
+                            s23 = input.charAt(peg$currPos);
+                            if (peg$r0.test(s23)) {
+                              peg$currPos++;
+                            } else {
+                              s23 = peg$FAILED;
+                              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                            }
+                            peg$silentFails--;
+                            if (s23 === peg$FAILED) {
+                              s22 = undefined;
+                            } else {
+                              peg$currPos = s22;
+                              s22 = peg$FAILED;
+                            }
+                            if (s22 !== peg$FAILED) {
+                              s14 = [s14, s15, s16, s17, s18, s19, s20, s21, s22];
+                              s13 = s14;
+                            } else {
+                              peg$currPos = s13;
+                              s13 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s13;
+                            s13 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s13;
+                          s13 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s13;
+                        s13 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s13;
+                      s13 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s13;
+                    s13 = peg$FAILED;
+                  }
+                }
+                peg$savedPos = s0;
+                s0 = peg$f135(s1, s3, s4, s6, s11, s12);
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGrantElementList() {
+    let s0, s1, s2, s3, s4, s5, s6, s7;
+
+    const key = peg$currPos * 508 + 90;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parseGrantElement();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$currPos;
+      s4 = peg$parse_();
+      if (input.charCodeAt(peg$currPos) === 44) {
+        s5 = peg$c24;
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
+      }
+      if (s5 !== peg$FAILED) {
+        s6 = peg$parse_();
+        s7 = peg$parseGrantElement();
+        if (s7 !== peg$FAILED) {
+          s4 = [s4, s5, s6, s7];
+          s3 = s4;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (input.charCodeAt(peg$currPos) === 44) {
+          s5 = peg$c24;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parse_();
+          s7 = peg$parseGrantElement();
+          if (s7 !== peg$FAILED) {
+            s4 = [s4, s5, s6, s7];
+            s3 = s4;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f136(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGrantElement() {
+    let s0, s1, s2, s3, s4, s5, s6;
+
+    const key = peg$currPos * 508 + 91;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parseGrantPrivilegeList();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parse_();
+      s3 = input.substr(peg$currPos, 2);
+      if (s3.toLowerCase() === peg$c94) {
+        peg$currPos += (2);
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e99); }
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$currPos;
+        peg$silentFails++;
+        s5 = input.charAt(peg$currPos);
+        if (peg$r0.test(s5)) {
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s5 === peg$FAILED) {
+          s4 = undefined;
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$parse_();
+          s6 = peg$parseGrantTarget();
+          if (s6 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f137(s1, s6);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGrantRoleList() {
+    let s0, s1, s2, s3, s4, s5, s6, s7;
+
+    const key = peg$currPos * 508 + 92;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parseGrantPrivilege();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$currPos;
+      s4 = peg$parse_();
+      if (input.charCodeAt(peg$currPos) === 44) {
+        s5 = peg$c24;
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
+      }
+      if (s5 !== peg$FAILED) {
+        s6 = peg$parse_();
+        s7 = peg$parseGrantPrivilege();
+        if (s7 !== peg$FAILED) {
+          s4 = [s4, s5, s6, s7];
+          s3 = s4;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (input.charCodeAt(peg$currPos) === 44) {
+          s5 = peg$c24;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parse_();
+          s7 = peg$parseGrantPrivilege();
+          if (s7 !== peg$FAILED) {
+            s4 = [s4, s5, s6, s7];
+            s3 = s4;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f138(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGrantPrivilegeList() {
+    let s0, s1, s2, s3, s4, s5, s6, s7;
+
+    const key = peg$currPos * 508 + 93;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parseGrantPrivilege();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$currPos;
+      s4 = peg$parse_();
+      if (input.charCodeAt(peg$currPos) === 44) {
+        s5 = peg$c24;
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
+      }
+      if (s5 !== peg$FAILED) {
+        s6 = peg$parse_();
+        s7 = peg$parseGrantPrivilege();
+        if (s7 !== peg$FAILED) {
+          s4 = [s4, s5, s6, s7];
+          s3 = s4;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (input.charCodeAt(peg$currPos) === 44) {
+          s5 = peg$c24;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parse_();
+          s7 = peg$parseGrantPrivilege();
+          if (s7 !== peg$FAILED) {
+            s4 = [s4, s5, s6, s7];
+            s3 = s4;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f139(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGrantPrivilege() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8;
+
+    const key = peg$currPos * 508 + 94;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parseGrantPrivilegeWords();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = peg$parse_();
+      if (input.charCodeAt(peg$currPos) === 40) {
+        s4 = peg$c25;
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
+      }
+      if (s4 !== peg$FAILED) {
+        s5 = peg$parse_();
+        s6 = peg$parseAliasNameList();
+        if (s6 !== peg$FAILED) {
+          s7 = peg$parse_();
+          if (input.charCodeAt(peg$currPos) === 41) {
+            s8 = peg$c26;
+            peg$currPos++;
+          } else {
+            s8 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e30); }
+          }
+          if (s8 !== peg$FAILED) {
+            s3 = [s3, s4, s5, s6, s7, s8];
+            s2 = s3;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      peg$savedPos = s0;
+      s0 = peg$f140(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGrantPrivilegeWords() {
+    let s0, s1, s2, s3, s4, s5;
+
+    const key = peg$currPos * 508 + 95;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parseGrantPrivilegeWord();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$currPos;
+      s4 = peg$parse_();
+      s5 = peg$parseGrantPrivilegeWord();
+      if (s5 !== peg$FAILED) {
+        s4 = [s4, s5];
+        s3 = s4;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        s5 = peg$parseGrantPrivilegeWord();
+        if (s5 !== peg$FAILED) {
+          s4 = [s4, s5];
+          s3 = s4;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f141(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGrantPrivilegeWord() {
+    let s0, s1, s2, s3, s4, s5, s6;
+
+    const key = peg$currPos * 508 + 96;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$currPos;
+    peg$silentFails++;
+    s2 = peg$currPos;
+    s3 = input.substr(peg$currPos, 2);
+    if (s3.toLowerCase() === peg$c94) {
+      peg$currPos += (2);
+    } else {
+      s3 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e99); }
+    }
+    if (s3 === peg$FAILED) {
+      s3 = input.substr(peg$currPos, 2);
+      if (s3.toLowerCase() === peg$c11) {
+        peg$currPos += (2);
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e13); }
+      }
+      if (s3 === peg$FAILED) {
+        s3 = input.substr(peg$currPos, 4);
+        if (s3.toLowerCase() === peg$c73) {
+          peg$currPos += (4);
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e78); }
+        }
+        if (s3 === peg$FAILED) {
+          s3 = input.substr(peg$currPos, 4);
+          if (s3.toLowerCase() === peg$c57) {
+            peg$currPos += (4);
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e62); }
+          }
+        }
+      }
+    }
+    if (s3 !== peg$FAILED) {
+      s4 = peg$currPos;
+      peg$silentFails++;
+      s5 = input.charAt(peg$currPos);
+      if (peg$r0.test(s5)) {
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s5 === peg$FAILED) {
+        s4 = undefined;
+      } else {
+        peg$currPos = s4;
+        s4 = peg$FAILED;
+      }
+      if (s4 !== peg$FAILED) {
+        s3 = [s3, s4];
+        s2 = s3;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s2;
+      s2 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s2 === peg$FAILED) {
+      s1 = undefined;
+    } else {
+      peg$currPos = s1;
+      s1 = peg$FAILED;
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = peg$currPos;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r5.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e129); }
+      }
+      if (s4 !== peg$FAILED) {
+        s5 = [];
+        s6 = input.charAt(peg$currPos);
+        if (peg$r0.test(s6)) {
+          peg$currPos++;
+        } else {
+          s6 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        while (s6 !== peg$FAILED) {
+          s5.push(s6);
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+        }
+        s4 = [s4, s5];
+        s3 = s4;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s2 = input.substring(s2, peg$currPos);
+      } else {
+        s2 = s3;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f142(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGrantTarget() {
+    let s0, s1, s2, s3, s4, s5;
+
+    const key = peg$currPos * 508 + 97;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parseGrantTargetPart();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parse_();
+      if (input.charCodeAt(peg$currPos) === 46) {
+        s3 = peg$c39;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        s5 = peg$parseGrantTargetPart();
+        if (s5 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f143(s1, s5);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseGrantTargetPart();
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$f144(s1);
+      }
+      s0 = s1;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGrantTargetPart() {
+    let s0, s1, s2, s3, s4, s5;
+
+    const key = peg$currPos * 508 + 98;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 42) {
+      s1 = peg$c123;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e130); }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f145();
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      s2 = peg$currPos;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r6.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e131); }
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = [];
+        s5 = input.charAt(peg$currPos);
+        if (peg$r7.test(s5)) {
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e132); }
+        }
+        while (s5 !== peg$FAILED) {
+          s4.push(s5);
+          s5 = input.charAt(peg$currPos);
+          if (peg$r7.test(s5)) {
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e132); }
+          }
+        }
+        if (input.charCodeAt(peg$currPos) === 42) {
+          s5 = peg$c123;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e130); }
+        }
+        if (s5 === peg$FAILED) {
+          s5 = null;
+        }
+        s3 = [s3, s4, s5];
+        s2 = s3;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s1 = input.substring(s1, peg$currPos);
+      } else {
+        s1 = s2;
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$f146(s1);
+      }
+      s0 = s1;
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 96) {
+          s1 = peg$c124;
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e133); }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = [];
+          s3 = peg$parseBacktickChar();
+          while (s3 !== peg$FAILED) {
+            s2.push(s3);
+            s3 = peg$parseBacktickChar();
+          }
+          if (input.charCodeAt(peg$currPos) === 96) {
+            s3 = peg$c124;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e133); }
+          }
+          if (s3 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f147(s2);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGranteeList() {
+    let s0, s1, s2, s3, s4, s5, s6, s7;
+
+    const key = peg$currPos * 508 + 99;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$parseGranteeName();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$currPos;
+      s4 = peg$parse_();
+      if (input.charCodeAt(peg$currPos) === 44) {
+        s5 = peg$c24;
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
+      }
+      if (s5 !== peg$FAILED) {
+        s6 = peg$parse_();
+        s7 = peg$parseGranteeName();
+        if (s7 !== peg$FAILED) {
+          s4 = [s4, s5, s6, s7];
+          s3 = s4;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (input.charCodeAt(peg$currPos) === 44) {
+          s5 = peg$c24;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parse_();
+          s7 = peg$parseGranteeName();
+          if (s7 !== peg$FAILED) {
+            s4 = [s4, s5, s6, s7];
+            s3 = s4;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f148(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseGranteeName() {
+    let s0, s1, s2, s3;
+
+    const key = peg$currPos * 508 + 100;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 12);
+    if (s1.toLowerCase() === peg$c125) {
+      peg$currPos += (12);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e134); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f149();
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseCreateUserNameItem();
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$f150(s1);
+      }
+      s0 = s1;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseAlterAccessStatement() {
+    let s0;
+
+    const key = peg$currPos * 508 + 101;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$parseAlterUserStatement();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseAlterRoleStatement();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseAlterQuotaStatement();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseAlterRowPolicyStatement();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseAlterSettingsProfileStatement();
+          }
+        }
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseAlterUserStatement() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
+
+    const key = peg$currPos * 508 + 102;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 5);
+    if (s1.toLowerCase() === peg$c21) {
+      peg$currPos += (5);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = input.substr(peg$currPos, 4);
+        if (s4.toLowerCase() === peg$c126) {
+          peg$currPos += (4);
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e135); }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          peg$silentFails++;
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s6 === peg$FAILED) {
+            s5 = undefined;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = peg$currPos;
+            s7 = peg$parse_();
+            s8 = input.substr(peg$currPos, 2);
+            if (s8.toLowerCase() === peg$c29) {
+              peg$currPos += (2);
+            } else {
+              s8 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
+            }
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              peg$silentFails++;
+              s10 = input.charAt(peg$currPos);
+              if (peg$r0.test(s10)) {
+                peg$currPos++;
+              } else {
+                s10 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s10 === peg$FAILED) {
+                s9 = undefined;
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 !== peg$FAILED) {
+                s10 = peg$parse_();
+                s11 = input.substr(peg$currPos, 6);
+                if (s11.toLowerCase() === peg$c31) {
+                  peg$currPos += (6);
+                } else {
+                  s11 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
+                }
+                if (s11 !== peg$FAILED) {
+                  s12 = peg$currPos;
+                  peg$silentFails++;
+                  s13 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s13)) {
+                    peg$currPos++;
+                  } else {
+                    s13 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s13 === peg$FAILED) {
+                    s12 = undefined;
+                  } else {
+                    peg$currPos = s12;
+                    s12 = peg$FAILED;
+                  }
+                  if (s12 !== peg$FAILED) {
+                    s7 = [s7, s8, s9, s10, s11, s12];
+                    s6 = s7;
+                  } else {
+                    peg$currPos = s6;
+                    s6 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s6;
+                  s6 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+            if (s6 === peg$FAILED) {
+              s6 = null;
+            }
+            s7 = peg$parse_();
+            s8 = peg$parseCreateUserNameList();
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              s10 = peg$parse_();
+              s11 = peg$parseOnClusterClause();
+              if (s11 !== peg$FAILED) {
+                s10 = [s10, s11];
+                s9 = s10;
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 === peg$FAILED) {
+                s9 = null;
+              }
+              s10 = [];
+              s11 = peg$currPos;
+              s12 = peg$parse_();
+              s13 = peg$parseAlterUserClause();
+              if (s13 !== peg$FAILED) {
+                s12 = [s12, s13];
+                s11 = s12;
+              } else {
+                peg$currPos = s11;
+                s11 = peg$FAILED;
+              }
+              while (s11 !== peg$FAILED) {
+                s10.push(s11);
+                s11 = peg$currPos;
+                s12 = peg$parse_();
+                s13 = peg$parseAlterUserClause();
+                if (s13 !== peg$FAILED) {
+                  s12 = [s12, s13];
+                  s11 = s12;
+                } else {
+                  peg$currPos = s11;
+                  s11 = peg$FAILED;
+                }
+              }
+              peg$savedPos = s0;
+              s0 = peg$f151(s6, s8, s9, s10);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseAlterUserClause() {
+    let s0, s1, s2, s3, s4, s5, s6, s7;
+
+    const key = peg$currPos * 508 + 103;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 6);
+    if (s1.toLowerCase() === peg$c55) {
+      peg$currPos += (6);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e60); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = input.substr(peg$currPos, 2);
+        if (s4.toLowerCase() === peg$c11) {
+          peg$currPos += (2);
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e13); }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          peg$silentFails++;
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s6 === peg$FAILED) {
+            s5 = undefined;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parse_();
+            s7 = peg$parseCreateUserNameItem();
+            if (s7 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f152(s7);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = input.substr(peg$currPos, 3);
+      if (s1.toLowerCase() === peg$c30) {
+        peg$currPos += (3);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e34); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r0.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parse_();
+          s4 = input.substr(peg$currPos, 10);
+          if (s4.toLowerCase() === peg$c127) {
+            peg$currPos += (10);
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e136); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$currPos;
+            peg$silentFails++;
+            s6 = input.charAt(peg$currPos);
+            if (peg$r0.test(s6)) {
+              peg$currPos++;
+            } else {
+              s6 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s6 === peg$FAILED) {
+              s5 = undefined;
+            } else {
+              peg$currPos = s5;
+              s5 = peg$FAILED;
+            }
+            if (s5 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f153();
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = input.substr(peg$currPos, 10);
+        if (s1.toLowerCase() === peg$c127) {
+          peg$currPos += (10);
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e136); }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$currPos;
+          peg$silentFails++;
+          s3 = input.charAt(peg$currPos);
+          if (peg$r0.test(s3)) {
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s3 === peg$FAILED) {
+            s2 = undefined;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+          if (s2 !== peg$FAILED) {
+            s3 = peg$parse_();
+            s4 = peg$parseCreateUserAuthMethods();
+            if (s4 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f154(s4);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = input.substr(peg$currPos, 3);
+          if (s1.toLowerCase() === peg$c27) {
+            peg$currPos += (3);
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e31); }
+          }
+          if (s1 === peg$FAILED) {
+            s1 = input.substr(peg$currPos, 4);
+            if (s1.toLowerCase() === peg$c34) {
+              peg$currPos += (4);
+            } else {
+              s1 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e38); }
+            }
+          }
+          if (s1 !== peg$FAILED) {
+            s2 = peg$currPos;
+            peg$silentFails++;
+            s3 = input.charAt(peg$currPos);
+            if (peg$r0.test(s3)) {
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s3 === peg$FAILED) {
+              s2 = undefined;
+            } else {
+              peg$currPos = s2;
+              s2 = peg$FAILED;
+            }
+            if (s2 !== peg$FAILED) {
+              s3 = peg$parse_();
+              s4 = input.substr(peg$currPos, 4);
+              if (s4.toLowerCase() === peg$c128) {
+                peg$currPos += (4);
+              } else {
+                s4 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e137); }
+              }
+              if (s4 !== peg$FAILED) {
+                s5 = peg$currPos;
+                peg$silentFails++;
+                s6 = input.charAt(peg$currPos);
+                if (peg$r0.test(s6)) {
+                  peg$currPos++;
+                } else {
+                  s6 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s6 === peg$FAILED) {
+                  s5 = undefined;
+                } else {
+                  peg$currPos = s5;
+                  s5 = peg$FAILED;
+                }
+                if (s5 !== peg$FAILED) {
+                  s6 = peg$parse_();
+                  s7 = peg$parseHostItemList();
+                  if (s7 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s0 = peg$f155(s1, s7);
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            s1 = input.substr(peg$currPos, 4);
+            if (s1.toLowerCase() === peg$c128) {
+              peg$currPos += (4);
+            } else {
+              s1 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e137); }
+            }
+            if (s1 !== peg$FAILED) {
+              s2 = peg$currPos;
+              peg$silentFails++;
+              s3 = input.charAt(peg$currPos);
+              if (peg$r0.test(s3)) {
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s3 === peg$FAILED) {
+                s2 = undefined;
+              } else {
+                peg$currPos = s2;
+                s2 = peg$FAILED;
+              }
+              if (s2 !== peg$FAILED) {
+                s3 = peg$parse_();
+                s4 = peg$parseHostItemList();
+                if (s4 !== peg$FAILED) {
+                  peg$savedPos = s0;
+                  s0 = peg$f156(s4);
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+            if (s0 === peg$FAILED) {
+              s0 = peg$currPos;
+              s1 = input.substr(peg$currPos, 8);
+              if (s1.toLowerCase() === peg$c47) {
+                peg$currPos += (8);
+              } else {
+                s1 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e51); }
+              }
+              if (s1 !== peg$FAILED) {
+                s2 = peg$currPos;
+                peg$silentFails++;
+                s3 = input.charAt(peg$currPos);
+                if (peg$r0.test(s3)) {
+                  peg$currPos++;
+                } else {
+                  s3 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s3 === peg$FAILED) {
+                  s2 = undefined;
+                } else {
+                  peg$currPos = s2;
+                  s2 = peg$FAILED;
+                }
+                if (s2 !== peg$FAILED) {
+                  s3 = peg$parse_();
+                  s4 = input.substr(peg$currPos, 4);
+                  if (s4.toLowerCase() === peg$c14) {
+                    peg$currPos += (4);
+                  } else {
+                    s4 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e16); }
+                  }
+                  if (s4 !== peg$FAILED) {
+                    s5 = peg$currPos;
+                    peg$silentFails++;
+                    s6 = input.charAt(peg$currPos);
+                    if (peg$r0.test(s6)) {
+                      peg$currPos++;
+                    } else {
+                      s6 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                    }
+                    peg$silentFails--;
+                    if (s6 === peg$FAILED) {
+                      s5 = undefined;
+                    } else {
+                      peg$currPos = s5;
+                      s5 = peg$FAILED;
+                    }
+                    if (s5 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s0 = peg$f157();
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+              if (s0 === peg$FAILED) {
+                s0 = peg$currPos;
+                s1 = input.substr(peg$currPos, 8);
+                if (s1.toLowerCase() === peg$c47) {
+                  peg$currPos += (8);
+                } else {
+                  s1 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e51); }
+                }
+                if (s1 !== peg$FAILED) {
+                  s2 = peg$currPos;
+                  peg$silentFails++;
+                  s3 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s3)) {
+                    peg$currPos++;
+                  } else {
+                    s3 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s3 === peg$FAILED) {
+                    s2 = undefined;
+                  } else {
+                    peg$currPos = s2;
+                    s2 = peg$FAILED;
+                  }
+                  if (s2 !== peg$FAILED) {
+                    s3 = peg$parse_();
+                    s4 = peg$parseAccessControlSettingsList();
+                    if (s4 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s0 = peg$f158(s4);
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+                if (s0 === peg$FAILED) {
+                  s0 = peg$currPos;
+                  s1 = input.substr(peg$currPos, 7);
+                  if (s1.toLowerCase() === peg$c9) {
+                    peg$currPos += (7);
+                  } else {
+                    s1 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e11); }
+                  }
+                  if (s1 !== peg$FAILED) {
+                    s2 = peg$currPos;
+                    peg$silentFails++;
+                    s3 = input.charAt(peg$currPos);
+                    if (peg$r0.test(s3)) {
+                      peg$currPos++;
+                    } else {
+                      s3 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                    }
+                    peg$silentFails--;
+                    if (s3 === peg$FAILED) {
+                      s2 = undefined;
+                    } else {
+                      peg$currPos = s2;
+                      s2 = peg$FAILED;
+                    }
+                    if (s2 !== peg$FAILED) {
+                      s3 = peg$parse_();
+                      s4 = input.substr(peg$currPos, 4);
+                      if (s4.toLowerCase() === peg$c10) {
+                        peg$currPos += (4);
+                      } else {
+                        s4 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e12); }
+                      }
+                      if (s4 !== peg$FAILED) {
+                        s5 = peg$currPos;
+                        peg$silentFails++;
+                        s6 = input.charAt(peg$currPos);
+                        if (peg$r0.test(s6)) {
+                          peg$currPos++;
+                        } else {
+                          s6 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                        }
+                        peg$silentFails--;
+                        if (s6 === peg$FAILED) {
+                          s5 = undefined;
+                        } else {
+                          peg$currPos = s5;
+                          s5 = peg$FAILED;
+                        }
+                        if (s5 !== peg$FAILED) {
+                          s6 = peg$parse_();
+                          s7 = peg$parseSetRoleList();
+                          if (s7 !== peg$FAILED) {
+                            peg$savedPos = s0;
+                            s0 = peg$f159(s7);
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                  if (s0 === peg$FAILED) {
+                    s0 = peg$currPos;
+                    s1 = input.substr(peg$currPos, 7);
+                    if (s1.toLowerCase() === peg$c9) {
+                      peg$currPos += (7);
+                    } else {
+                      s1 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e11); }
+                    }
+                    if (s1 !== peg$FAILED) {
+                      s2 = peg$currPos;
+                      peg$silentFails++;
+                      s3 = input.charAt(peg$currPos);
+                      if (peg$r0.test(s3)) {
+                        peg$currPos++;
+                      } else {
+                        s3 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                      }
+                      peg$silentFails--;
+                      if (s3 === peg$FAILED) {
+                        s2 = undefined;
+                      } else {
+                        peg$currPos = s2;
+                        s2 = peg$FAILED;
+                      }
+                      if (s2 !== peg$FAILED) {
+                        s3 = peg$parse_();
+                        s4 = input.substr(peg$currPos, 8);
+                        if (s4.toLowerCase() === peg$c112) {
+                          peg$currPos += (8);
+                        } else {
+                          s4 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$e118); }
+                        }
+                        if (s4 !== peg$FAILED) {
+                          s5 = peg$currPos;
+                          peg$silentFails++;
+                          s6 = input.charAt(peg$currPos);
+                          if (peg$r0.test(s6)) {
+                            peg$currPos++;
+                          } else {
+                            s6 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                          }
+                          peg$silentFails--;
+                          if (s6 === peg$FAILED) {
+                            s5 = undefined;
+                          } else {
+                            peg$currPos = s5;
+                            s5 = peg$FAILED;
+                          }
+                          if (s5 !== peg$FAILED) {
+                            s6 = peg$parse_();
+                            s7 = peg$parseAliasName();
+                            if (s7 !== peg$FAILED) {
+                              peg$savedPos = s0;
+                              s0 = peg$f160(s7);
+                            } else {
+                              peg$currPos = s0;
+                              s0 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                    if (s0 === peg$FAILED) {
+                      s0 = peg$currPos;
+                      s1 = input.substr(peg$currPos, 8);
+                      if (s1.toLowerCase() === peg$c129) {
+                        peg$currPos += (8);
+                      } else {
+                        s1 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e138); }
+                      }
+                      if (s1 !== peg$FAILED) {
+                        s2 = peg$currPos;
+                        peg$silentFails++;
+                        s3 = input.charAt(peg$currPos);
+                        if (peg$r0.test(s3)) {
+                          peg$currPos++;
+                        } else {
+                          s3 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                        }
+                        peg$silentFails--;
+                        if (s3 === peg$FAILED) {
+                          s2 = undefined;
+                        } else {
+                          peg$currPos = s2;
+                          s2 = peg$FAILED;
+                        }
+                        if (s2 !== peg$FAILED) {
+                          s3 = peg$parse_();
+                          s4 = peg$parseSetRoleList();
+                          if (s4 !== peg$FAILED) {
+                            peg$savedPos = s0;
+                            s0 = peg$f161(s4);
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                      if (s0 === peg$FAILED) {
+                        s0 = peg$currPos;
+                        s1 = input.substr(peg$currPos, 5);
+                        if (s1.toLowerCase() === peg$c130) {
+                          peg$currPos += (5);
+                        } else {
+                          s1 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$e139); }
+                        }
+                        if (s1 !== peg$FAILED) {
+                          s2 = peg$currPos;
+                          peg$silentFails++;
+                          s3 = input.charAt(peg$currPos);
+                          if (peg$r0.test(s3)) {
+                            peg$currPos++;
+                          } else {
+                            s3 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                          }
+                          peg$silentFails--;
+                          if (s3 === peg$FAILED) {
+                            s2 = undefined;
+                          } else {
+                            peg$currPos = s2;
+                            s2 = peg$FAILED;
+                          }
+                          if (s2 !== peg$FAILED) {
+                            s3 = peg$parse_();
+                            s4 = input.substr(peg$currPos, 5);
+                            if (s4.toLowerCase() === peg$c131) {
+                              peg$currPos += (5);
+                            } else {
+                              s4 = peg$FAILED;
+                              if (peg$silentFails === 0) { peg$fail(peg$e140); }
+                            }
+                            if (s4 !== peg$FAILED) {
+                              s5 = peg$currPos;
+                              peg$silentFails++;
+                              s6 = input.charAt(peg$currPos);
+                              if (peg$r0.test(s6)) {
+                                peg$currPos++;
+                              } else {
+                                s6 = peg$FAILED;
+                                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                              }
+                              peg$silentFails--;
+                              if (s6 === peg$FAILED) {
+                                s5 = undefined;
+                              } else {
+                                peg$currPos = s5;
+                                s5 = peg$FAILED;
+                              }
+                              if (s5 !== peg$FAILED) {
+                                s6 = peg$parse_();
+                                s7 = peg$parseStringLiteral();
+                                if (s7 !== peg$FAILED) {
+                                  peg$savedPos = s0;
+                                  s0 = peg$f162(s7);
+                                } else {
+                                  peg$currPos = s0;
+                                  s0 = peg$FAILED;
+                                }
+                              } else {
+                                peg$currPos = s0;
+                                s0 = peg$FAILED;
+                              }
+                            } else {
+                              peg$currPos = s0;
+                              s0 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseAlterRoleStatement() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18;
+
+    const key = peg$currPos * 508 + 104;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 5);
+    if (s1.toLowerCase() === peg$c21) {
+      peg$currPos += (5);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = input.substr(peg$currPos, 4);
+        if (s4.toLowerCase() === peg$c10) {
+          peg$currPos += (4);
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e12); }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          peg$silentFails++;
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s6 === peg$FAILED) {
+            s5 = undefined;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = peg$currPos;
+            s7 = peg$parse_();
+            s8 = input.substr(peg$currPos, 2);
+            if (s8.toLowerCase() === peg$c29) {
+              peg$currPos += (2);
+            } else {
+              s8 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
+            }
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              peg$silentFails++;
+              s10 = input.charAt(peg$currPos);
+              if (peg$r0.test(s10)) {
+                peg$currPos++;
+              } else {
+                s10 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s10 === peg$FAILED) {
+                s9 = undefined;
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 !== peg$FAILED) {
+                s10 = peg$parse_();
+                s11 = input.substr(peg$currPos, 6);
+                if (s11.toLowerCase() === peg$c31) {
+                  peg$currPos += (6);
+                } else {
+                  s11 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
+                }
+                if (s11 !== peg$FAILED) {
+                  s12 = peg$currPos;
+                  peg$silentFails++;
+                  s13 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s13)) {
+                    peg$currPos++;
+                  } else {
+                    s13 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s13 === peg$FAILED) {
+                    s12 = undefined;
+                  } else {
+                    peg$currPos = s12;
+                    s12 = peg$FAILED;
+                  }
+                  if (s12 !== peg$FAILED) {
+                    s7 = [s7, s8, s9, s10, s11, s12];
+                    s6 = s7;
+                  } else {
+                    peg$currPos = s6;
+                    s6 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s6;
+                  s6 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+            if (s6 === peg$FAILED) {
+              s6 = null;
+            }
+            s7 = peg$parse_();
+            s8 = peg$parseCreateUserNameList();
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              s10 = peg$parse_();
+              s11 = peg$parseOnClusterClause();
+              if (s11 !== peg$FAILED) {
+                s10 = [s10, s11];
+                s9 = s10;
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 === peg$FAILED) {
+                s9 = null;
+              }
+              s10 = peg$currPos;
+              s11 = peg$parse_();
+              s12 = input.substr(peg$currPos, 6);
+              if (s12.toLowerCase() === peg$c55) {
+                peg$currPos += (6);
+              } else {
+                s12 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e60); }
+              }
+              if (s12 !== peg$FAILED) {
+                s13 = peg$currPos;
+                peg$silentFails++;
+                s14 = input.charAt(peg$currPos);
+                if (peg$r0.test(s14)) {
+                  peg$currPos++;
+                } else {
+                  s14 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s14 === peg$FAILED) {
+                  s13 = undefined;
+                } else {
+                  peg$currPos = s13;
+                  s13 = peg$FAILED;
+                }
+                if (s13 !== peg$FAILED) {
+                  s14 = peg$parse_();
+                  s15 = input.substr(peg$currPos, 2);
+                  if (s15.toLowerCase() === peg$c11) {
+                    peg$currPos += (2);
+                  } else {
+                    s15 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e13); }
+                  }
+                  if (s15 !== peg$FAILED) {
+                    s16 = peg$currPos;
+                    peg$silentFails++;
+                    s17 = input.charAt(peg$currPos);
+                    if (peg$r0.test(s17)) {
+                      peg$currPos++;
+                    } else {
+                      s17 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                    }
+                    peg$silentFails--;
+                    if (s17 === peg$FAILED) {
+                      s16 = undefined;
+                    } else {
+                      peg$currPos = s16;
+                      s16 = peg$FAILED;
+                    }
+                    if (s16 !== peg$FAILED) {
+                      s17 = peg$parse_();
+                      s18 = peg$parseCreateUserNameItem();
+                      if (s18 !== peg$FAILED) {
+                        s11 = [s11, s12, s13, s14, s15, s16, s17, s18];
+                        s10 = s11;
+                      } else {
+                        peg$currPos = s10;
+                        s10 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s10;
+                      s10 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s10;
+                    s10 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s10;
+                  s10 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s10;
+                s10 = peg$FAILED;
+              }
+              if (s10 === peg$FAILED) {
+                s10 = null;
+              }
+              s11 = peg$currPos;
+              s12 = peg$parse_();
+              s13 = peg$parseCreateRoleSettingsClause();
+              if (s13 !== peg$FAILED) {
+                s12 = [s12, s13];
+                s11 = s12;
+              } else {
+                peg$currPos = s11;
+                s11 = peg$FAILED;
+              }
+              if (s11 === peg$FAILED) {
+                s11 = null;
+              }
+              peg$savedPos = s0;
+              s0 = peg$f163(s6, s8, s9, s10, s11);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseAlterQuotaStatement() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18;
+
+    const key = peg$currPos * 508 + 105;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 5);
+    if (s1.toLowerCase() === peg$c21) {
+      peg$currPos += (5);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = input.substr(peg$currPos, 5);
+        if (s4.toLowerCase() === peg$c132) {
+          peg$currPos += (5);
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e141); }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          peg$silentFails++;
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s6 === peg$FAILED) {
+            s5 = undefined;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = peg$currPos;
+            s7 = peg$parse_();
+            s8 = input.substr(peg$currPos, 2);
+            if (s8.toLowerCase() === peg$c29) {
+              peg$currPos += (2);
+            } else {
+              s8 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
+            }
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              peg$silentFails++;
+              s10 = input.charAt(peg$currPos);
+              if (peg$r0.test(s10)) {
+                peg$currPos++;
+              } else {
+                s10 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s10 === peg$FAILED) {
+                s9 = undefined;
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 !== peg$FAILED) {
+                s10 = peg$parse_();
+                s11 = input.substr(peg$currPos, 6);
+                if (s11.toLowerCase() === peg$c31) {
+                  peg$currPos += (6);
+                } else {
+                  s11 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
+                }
+                if (s11 !== peg$FAILED) {
+                  s12 = peg$currPos;
+                  peg$silentFails++;
+                  s13 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s13)) {
+                    peg$currPos++;
+                  } else {
+                    s13 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s13 === peg$FAILED) {
+                    s12 = undefined;
+                  } else {
+                    peg$currPos = s12;
+                    s12 = peg$FAILED;
+                  }
+                  if (s12 !== peg$FAILED) {
+                    s7 = [s7, s8, s9, s10, s11, s12];
+                    s6 = s7;
+                  } else {
+                    peg$currPos = s6;
+                    s6 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s6;
+                  s6 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+            if (s6 === peg$FAILED) {
+              s6 = null;
+            }
+            s7 = peg$parse_();
+            s8 = peg$parseQuotaNameList();
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              s10 = peg$parse_();
+              s11 = peg$parseOnClusterClause();
+              if (s11 !== peg$FAILED) {
+                s10 = [s10, s11];
+                s9 = s10;
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 === peg$FAILED) {
+                s9 = null;
+              }
+              s10 = peg$currPos;
+              s11 = peg$parse_();
+              s12 = input.substr(peg$currPos, 6);
+              if (s12.toLowerCase() === peg$c55) {
+                peg$currPos += (6);
+              } else {
+                s12 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e60); }
+              }
+              if (s12 !== peg$FAILED) {
+                s13 = peg$currPos;
+                peg$silentFails++;
+                s14 = input.charAt(peg$currPos);
+                if (peg$r0.test(s14)) {
+                  peg$currPos++;
+                } else {
+                  s14 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s14 === peg$FAILED) {
+                  s13 = undefined;
+                } else {
+                  peg$currPos = s13;
+                  s13 = peg$FAILED;
+                }
+                if (s13 !== peg$FAILED) {
+                  s14 = peg$parse_();
+                  s15 = input.substr(peg$currPos, 2);
+                  if (s15.toLowerCase() === peg$c11) {
+                    peg$currPos += (2);
+                  } else {
+                    s15 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e13); }
+                  }
+                  if (s15 !== peg$FAILED) {
+                    s16 = peg$currPos;
+                    peg$silentFails++;
+                    s17 = input.charAt(peg$currPos);
+                    if (peg$r0.test(s17)) {
+                      peg$currPos++;
+                    } else {
+                      s17 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                    }
+                    peg$silentFails--;
+                    if (s17 === peg$FAILED) {
+                      s16 = undefined;
+                    } else {
+                      peg$currPos = s16;
+                      s16 = peg$FAILED;
+                    }
+                    if (s16 !== peg$FAILED) {
+                      s17 = peg$parse_();
+                      s18 = peg$parseAccessControlNameValue();
+                      if (s18 !== peg$FAILED) {
+                        s11 = [s11, s12, s13, s14, s15, s16, s17, s18];
+                        s10 = s11;
+                      } else {
+                        peg$currPos = s10;
+                        s10 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s10;
+                      s10 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s10;
+                    s10 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s10;
+                  s10 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s10;
+                s10 = peg$FAILED;
+              }
+              if (s10 === peg$FAILED) {
+                s10 = null;
+              }
+              s11 = [];
+              s12 = peg$currPos;
+              s13 = peg$parse_();
+              if (input.charCodeAt(peg$currPos) === 44) {
+                s14 = peg$c24;
+                peg$currPos++;
+              } else {
+                s14 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
+              }
+              if (s14 === peg$FAILED) {
+                s14 = null;
+              }
+              s15 = peg$parse_();
+              s16 = peg$parseQuotaClause();
+              if (s16 !== peg$FAILED) {
+                s13 = [s13, s14, s15, s16];
+                s12 = s13;
+              } else {
+                peg$currPos = s12;
+                s12 = peg$FAILED;
+              }
+              while (s12 !== peg$FAILED) {
+                s11.push(s12);
+                s12 = peg$currPos;
+                s13 = peg$parse_();
+                if (input.charCodeAt(peg$currPos) === 44) {
+                  s14 = peg$c24;
+                  peg$currPos++;
+                } else {
+                  s14 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
+                }
+                if (s14 === peg$FAILED) {
+                  s14 = null;
+                }
+                s15 = peg$parse_();
+                s16 = peg$parseQuotaClause();
+                if (s16 !== peg$FAILED) {
+                  s13 = [s13, s14, s15, s16];
+                  s12 = s13;
+                } else {
+                  peg$currPos = s12;
+                  s12 = peg$FAILED;
+                }
+              }
+              peg$savedPos = s0;
+              s0 = peg$f164(s6, s8, s9, s10, s11);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseAlterRowPolicyStatement() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14;
+
+    const key = peg$currPos * 508 + 106;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 5);
+    if (s1.toLowerCase() === peg$c21) {
+      peg$currPos += (5);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = peg$currPos;
+        s5 = input.substr(peg$currPos, 3);
+        if (s5.toLowerCase() === peg$c133) {
+          peg$currPos += (3);
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e142); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$currPos;
+          peg$silentFails++;
+          s7 = input.charAt(peg$currPos);
+          if (peg$r0.test(s7)) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s7 === peg$FAILED) {
+            s6 = undefined;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            s7 = peg$parse_();
+            s5 = [s5, s6, s7];
+            s4 = s5;
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+        if (s4 === peg$FAILED) {
+          s4 = null;
+        }
+        s5 = input.substr(peg$currPos, 6);
+        if (s5.toLowerCase() === peg$c134) {
+          peg$currPos += (6);
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e143); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$currPos;
+          peg$silentFails++;
+          s7 = input.charAt(peg$currPos);
+          if (peg$r0.test(s7)) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s7 === peg$FAILED) {
+            s6 = undefined;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            s7 = peg$currPos;
+            s8 = peg$parse_();
+            s9 = input.substr(peg$currPos, 2);
+            if (s9.toLowerCase() === peg$c29) {
+              peg$currPos += (2);
+            } else {
+              s9 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
+            }
+            if (s9 !== peg$FAILED) {
+              s10 = peg$currPos;
+              peg$silentFails++;
+              s11 = input.charAt(peg$currPos);
+              if (peg$r0.test(s11)) {
+                peg$currPos++;
+              } else {
+                s11 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s11 === peg$FAILED) {
+                s10 = undefined;
+              } else {
+                peg$currPos = s10;
+                s10 = peg$FAILED;
+              }
+              if (s10 !== peg$FAILED) {
+                s11 = peg$parse_();
+                s12 = input.substr(peg$currPos, 6);
+                if (s12.toLowerCase() === peg$c31) {
+                  peg$currPos += (6);
+                } else {
+                  s12 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
+                }
+                if (s12 !== peg$FAILED) {
+                  s13 = peg$currPos;
+                  peg$silentFails++;
+                  s14 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s14)) {
+                    peg$currPos++;
+                  } else {
+                    s14 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s14 === peg$FAILED) {
+                    s13 = undefined;
+                  } else {
+                    peg$currPos = s13;
+                    s13 = peg$FAILED;
+                  }
+                  if (s13 !== peg$FAILED) {
+                    s8 = [s8, s9, s10, s11, s12, s13];
+                    s7 = s8;
+                  } else {
+                    peg$currPos = s7;
+                    s7 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s7;
+                  s7 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s7;
+                s7 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s7;
+              s7 = peg$FAILED;
+            }
+            if (s7 === peg$FAILED) {
+              s7 = null;
+            }
+            s8 = peg$parse_();
+            s9 = peg$parseRowPolicyTargets();
+            if (s9 !== peg$FAILED) {
+              s10 = [];
+              s11 = peg$currPos;
+              s12 = peg$parse_();
+              s13 = peg$parseAlterRowPolicyClause();
+              if (s13 !== peg$FAILED) {
+                s12 = [s12, s13];
+                s11 = s12;
+              } else {
+                peg$currPos = s11;
+                s11 = peg$FAILED;
+              }
+              while (s11 !== peg$FAILED) {
+                s10.push(s11);
+                s11 = peg$currPos;
+                s12 = peg$parse_();
+                s13 = peg$parseAlterRowPolicyClause();
+                if (s13 !== peg$FAILED) {
+                  s12 = [s12, s13];
+                  s11 = s12;
+                } else {
+                  peg$currPos = s11;
+                  s11 = peg$FAILED;
+                }
+              }
+              peg$savedPos = s0;
+              s0 = peg$f165(s4, s7, s9, s10);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseAlterRowPolicyClause() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8;
+
+    const key = peg$currPos * 508 + 107;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 6);
+    if (s1.toLowerCase() === peg$c55) {
+      peg$currPos += (6);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e60); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = input.substr(peg$currPos, 2);
+        if (s4.toLowerCase() === peg$c11) {
+          peg$currPos += (2);
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e13); }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          peg$silentFails++;
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s6 === peg$FAILED) {
+            s5 = undefined;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parse_();
+            s7 = peg$parseAccessControlNameValue();
+            if (s7 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f166(s7);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = input.substr(peg$currPos, 3);
+      if (s1.toLowerCase() === peg$c122) {
+        peg$currPos += (3);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e128); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r0.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parse_();
+          s4 = input.substr(peg$currPos, 6);
+          if (s4.toLowerCase() === peg$c135) {
+            peg$currPos += (6);
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e144); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$currPos;
+            peg$silentFails++;
+            s6 = input.charAt(peg$currPos);
+            if (peg$r0.test(s6)) {
+              peg$currPos++;
+            } else {
+              s6 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s6 === peg$FAILED) {
+              s5 = undefined;
+            } else {
+              peg$currPos = s5;
+              s5 = peg$FAILED;
+            }
+            if (s5 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f167();
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = input.substr(peg$currPos, 5);
+        if (s1.toLowerCase() === peg$c136) {
+          peg$currPos += (5);
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e145); }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$currPos;
+          peg$silentFails++;
+          s3 = input.charAt(peg$currPos);
+          if (peg$r0.test(s3)) {
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s3 === peg$FAILED) {
+            s2 = undefined;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+          if (s2 !== peg$FAILED) {
+            s3 = peg$parse_();
+            s4 = peg$parseExpression();
+            if (s4 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f168(s4);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = input.substr(peg$currPos, 2);
+          if (s1.toLowerCase() === peg$c5) {
+            peg$currPos += (2);
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e6); }
+          }
+          if (s1 !== peg$FAILED) {
+            s2 = peg$currPos;
+            peg$silentFails++;
+            s3 = input.charAt(peg$currPos);
+            if (peg$r0.test(s3)) {
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s3 === peg$FAILED) {
+              s2 = undefined;
+            } else {
+              peg$currPos = s2;
+              s2 = peg$FAILED;
+            }
+            if (s2 !== peg$FAILED) {
+              s3 = peg$parse_();
+              s4 = input.substr(peg$currPos, 11);
+              if (s4.toLowerCase() === peg$c137) {
+                peg$currPos += (11);
+              } else {
+                s4 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e146); }
+              }
+              if (s4 === peg$FAILED) {
+                s4 = input.substr(peg$currPos, 10);
+                if (s4.toLowerCase() === peg$c138) {
+                  peg$currPos += (10);
+                } else {
+                  s4 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e147); }
+                }
+              }
+              if (s4 !== peg$FAILED) {
+                s5 = peg$currPos;
+                peg$silentFails++;
+                s6 = input.charAt(peg$currPos);
+                if (peg$r0.test(s6)) {
+                  peg$currPos++;
+                } else {
+                  s6 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s6 === peg$FAILED) {
+                  s5 = undefined;
+                } else {
+                  peg$currPos = s5;
+                  s5 = peg$FAILED;
+                }
+                if (s5 !== peg$FAILED) {
+                  peg$savedPos = s0;
+                  s0 = peg$f169(s4);
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            s1 = input.substr(peg$currPos, 2);
+            if (s1.toLowerCase() === peg$c11) {
+              peg$currPos += (2);
+            } else {
+              s1 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e13); }
+            }
+            if (s1 !== peg$FAILED) {
+              s2 = peg$currPos;
+              peg$silentFails++;
+              s3 = input.charAt(peg$currPos);
+              if (peg$r0.test(s3)) {
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s3 === peg$FAILED) {
+                s2 = undefined;
+              } else {
+                peg$currPos = s2;
+                s2 = peg$FAILED;
+              }
+              if (s2 !== peg$FAILED) {
+                s3 = peg$parse_();
+                s4 = peg$parseSetRoleList();
+                if (s4 !== peg$FAILED) {
+                  peg$savedPos = s0;
+                  s0 = peg$f170(s4);
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+            if (s0 === peg$FAILED) {
+              s0 = peg$currPos;
+              s1 = input.substr(peg$currPos, 2);
+              if (s1.toLowerCase() === peg$c94) {
+                peg$currPos += (2);
+              } else {
+                s1 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e99); }
+              }
+              if (s1 !== peg$FAILED) {
+                s2 = peg$currPos;
+                peg$silentFails++;
+                s3 = input.charAt(peg$currPos);
+                if (peg$r0.test(s3)) {
+                  peg$currPos++;
+                } else {
+                  s3 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s3 === peg$FAILED) {
+                  s2 = undefined;
+                } else {
+                  peg$currPos = s2;
+                  s2 = peg$FAILED;
+                }
+                if (s2 !== peg$FAILED) {
+                  s3 = peg$parse_();
+                  s4 = input.substr(peg$currPos, 7);
+                  if (s4.toLowerCase() === peg$c139) {
+                    peg$currPos += (7);
+                  } else {
+                    s4 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e148); }
+                  }
+                  if (s4 !== peg$FAILED) {
+                    s5 = peg$currPos;
+                    peg$silentFails++;
+                    s6 = input.charAt(peg$currPos);
+                    if (peg$r0.test(s6)) {
+                      peg$currPos++;
+                    } else {
+                      s6 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                    }
+                    peg$silentFails--;
+                    if (s6 === peg$FAILED) {
+                      s5 = undefined;
+                    } else {
+                      peg$currPos = s5;
+                      s5 = peg$FAILED;
+                    }
+                    if (s5 !== peg$FAILED) {
+                      s6 = peg$parse_();
+                      s7 = peg$currPos;
+                      s8 = peg$parseStringLiteral();
+                      if (s8 !== peg$FAILED) {
+                        peg$savedPos = s7;
+                        s8 = peg$f171();
+                      }
+                      s7 = s8;
+                      if (s7 === peg$FAILED) {
+                        s7 = peg$parseAliasName();
+                      }
+                      if (s7 !== peg$FAILED) {
+                        peg$savedPos = s0;
+                        s0 = peg$f172(s7);
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseAlterSettingsProfileStatement() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19;
+
+    const key = peg$currPos * 508 + 108;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 5);
+    if (s1.toLowerCase() === peg$c21) {
+      peg$currPos += (5);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = peg$currPos;
+        s5 = input.substr(peg$currPos, 8);
+        if (s5.toLowerCase() === peg$c47) {
+          peg$currPos += (8);
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e51); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$currPos;
+          peg$silentFails++;
+          s7 = input.charAt(peg$currPos);
+          if (peg$r0.test(s7)) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s7 === peg$FAILED) {
+            s6 = undefined;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            s7 = peg$parse_();
+            s5 = [s5, s6, s7];
+            s4 = s5;
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+        if (s4 === peg$FAILED) {
+          s4 = null;
+        }
+        s5 = input.substr(peg$currPos, 7);
+        if (s5.toLowerCase() === peg$c140) {
+          peg$currPos += (7);
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e149); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$currPos;
+          peg$silentFails++;
+          s7 = input.charAt(peg$currPos);
+          if (peg$r0.test(s7)) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s7 === peg$FAILED) {
+            s6 = undefined;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            s7 = peg$currPos;
+            s8 = peg$parse_();
+            s9 = input.substr(peg$currPos, 2);
+            if (s9.toLowerCase() === peg$c29) {
+              peg$currPos += (2);
+            } else {
+              s9 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
+            }
+            if (s9 !== peg$FAILED) {
+              s10 = peg$currPos;
+              peg$silentFails++;
+              s11 = input.charAt(peg$currPos);
+              if (peg$r0.test(s11)) {
+                peg$currPos++;
+              } else {
+                s11 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s11 === peg$FAILED) {
+                s10 = undefined;
+              } else {
+                peg$currPos = s10;
+                s10 = peg$FAILED;
+              }
+              if (s10 !== peg$FAILED) {
+                s11 = peg$parse_();
+                s12 = input.substr(peg$currPos, 6);
+                if (s12.toLowerCase() === peg$c31) {
+                  peg$currPos += (6);
+                } else {
+                  s12 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
+                }
+                if (s12 !== peg$FAILED) {
+                  s13 = peg$currPos;
+                  peg$silentFails++;
+                  s14 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s14)) {
+                    peg$currPos++;
+                  } else {
+                    s14 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s14 === peg$FAILED) {
+                    s13 = undefined;
+                  } else {
+                    peg$currPos = s13;
+                    s13 = peg$FAILED;
+                  }
+                  if (s13 !== peg$FAILED) {
+                    s8 = [s8, s9, s10, s11, s12, s13];
+                    s7 = s8;
+                  } else {
+                    peg$currPos = s7;
+                    s7 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s7;
+                  s7 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s7;
+                s7 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s7;
+              s7 = peg$FAILED;
+            }
+            if (s7 === peg$FAILED) {
+              s7 = null;
+            }
+            s8 = peg$parse_();
+            s9 = peg$parseQuotaNameList();
+            if (s9 !== peg$FAILED) {
+              s10 = peg$currPos;
+              s11 = peg$parse_();
+              s12 = peg$parseOnClusterClause();
+              if (s12 !== peg$FAILED) {
+                s11 = [s11, s12];
+                s10 = s11;
+              } else {
+                peg$currPos = s10;
+                s10 = peg$FAILED;
+              }
+              if (s10 === peg$FAILED) {
+                s10 = null;
+              }
+              s11 = peg$currPos;
+              s12 = peg$parse_();
+              s13 = input.substr(peg$currPos, 6);
+              if (s13.toLowerCase() === peg$c55) {
+                peg$currPos += (6);
+              } else {
+                s13 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e60); }
+              }
+              if (s13 !== peg$FAILED) {
+                s14 = peg$currPos;
+                peg$silentFails++;
+                s15 = input.charAt(peg$currPos);
+                if (peg$r0.test(s15)) {
+                  peg$currPos++;
+                } else {
+                  s15 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s15 === peg$FAILED) {
+                  s14 = undefined;
+                } else {
+                  peg$currPos = s14;
+                  s14 = peg$FAILED;
+                }
+                if (s14 !== peg$FAILED) {
+                  s15 = peg$parse_();
+                  s16 = input.substr(peg$currPos, 2);
+                  if (s16.toLowerCase() === peg$c11) {
+                    peg$currPos += (2);
+                  } else {
+                    s16 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e13); }
+                  }
+                  if (s16 !== peg$FAILED) {
+                    s17 = peg$currPos;
+                    peg$silentFails++;
+                    s18 = input.charAt(peg$currPos);
+                    if (peg$r0.test(s18)) {
+                      peg$currPos++;
+                    } else {
+                      s18 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                    }
+                    peg$silentFails--;
+                    if (s18 === peg$FAILED) {
+                      s17 = undefined;
+                    } else {
+                      peg$currPos = s17;
+                      s17 = peg$FAILED;
+                    }
+                    if (s17 !== peg$FAILED) {
+                      s18 = peg$parse_();
+                      s19 = peg$parseAccessControlNameValue();
+                      if (s19 !== peg$FAILED) {
+                        s12 = [s12, s13, s14, s15, s16, s17, s18, s19];
+                        s11 = s12;
+                      } else {
+                        peg$currPos = s11;
+                        s11 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s11;
+                      s11 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s11;
+                    s11 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s11;
+                  s11 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s11;
+                s11 = peg$FAILED;
+              }
+              if (s11 === peg$FAILED) {
+                s11 = null;
+              }
+              s12 = peg$currPos;
+              s13 = peg$parse_();
+              s14 = peg$parseCreateRoleSettingsClause();
+              if (s14 !== peg$FAILED) {
+                s13 = [s13, s14];
+                s12 = s13;
+              } else {
+                peg$currPos = s12;
+                s12 = peg$FAILED;
+              }
+              if (s12 === peg$FAILED) {
+                s12 = null;
+              }
+              s13 = peg$currPos;
+              s14 = peg$parse_();
+              s15 = input.substr(peg$currPos, 2);
+              if (s15.toLowerCase() === peg$c11) {
+                peg$currPos += (2);
+              } else {
+                s15 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e13); }
+              }
+              if (s15 !== peg$FAILED) {
+                s16 = peg$currPos;
+                peg$silentFails++;
+                s17 = input.charAt(peg$currPos);
+                if (peg$r0.test(s17)) {
+                  peg$currPos++;
+                } else {
+                  s17 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s17 === peg$FAILED) {
+                  s16 = undefined;
+                } else {
+                  peg$currPos = s16;
+                  s16 = peg$FAILED;
+                }
+                if (s16 !== peg$FAILED) {
+                  s17 = peg$parse_();
+                  s18 = peg$parseSetRoleList();
+                  if (s18 !== peg$FAILED) {
+                    s14 = [s14, s15, s16, s17, s18];
+                    s13 = s14;
+                  } else {
+                    peg$currPos = s13;
+                    s13 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s13;
+                  s13 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s13;
+                s13 = peg$FAILED;
+              }
+              if (s13 === peg$FAILED) {
+                s13 = null;
+              }
+              peg$savedPos = s0;
+              s0 = peg$f173(s4, s7, s9, s10, s11, s12, s13);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowStatement() {
+    let s0, s1, s2, s3, s4, s5, s6, s7;
+
+    const key = peg$currPos * 508 + 109;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 4);
+    if (s1.toLowerCase() === peg$c141) {
+      peg$currPos += (4);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e150); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = peg$parseShowBody();
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          s6 = peg$parse_();
+          s7 = peg$parseFormatClause();
+          if (s7 !== peg$FAILED) {
+            s6 = [s6, s7];
+            s5 = s6;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 === peg$FAILED) {
+            s5 = null;
+          }
+          peg$savedPos = s0;
+          s0 = peg$f174(s4, s5);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowBody() {
+    let s0;
+
+    const key = peg$currPos * 508 + 110;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$parseShowCreateAccessBody();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseShowColumnsBody();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseShowIndexesBody();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseShowGrantsBody();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseShowListingBody();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseShowAccessEntitiesBody();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parseShowSettingBody();
+                if (s0 === peg$FAILED) {
+                  s0 = peg$parseShowSimpleBody();
+                  if (s0 === peg$FAILED) {
+                    s0 = peg$parseShowClusterBody();
+                    if (s0 === peg$FAILED) {
+                      s0 = peg$parseShowObjectShorthandBody();
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowCreateAccessBody() {
+    let s0, s1, s2, s3, s4, s5, s6;
+
+    const key = peg$currPos * 508 + 111;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 6);
+    if (s1.toLowerCase() === peg$c142) {
+      peg$currPos += (6);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = peg$parseShowRowPolicyKeyword();
+        if (s4 !== peg$FAILED) {
+          s5 = peg$parse_();
+          s6 = peg$parseRowPolicyTargets();
+          if (s6 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f175(s6);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = input.substr(peg$currPos, 6);
+      if (s1.toLowerCase() === peg$c142) {
+        peg$currPos += (6);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e151); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r0.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parse_();
+          s4 = peg$parseShowRowPolicyKeyword();
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parse_();
+            s6 = peg$parseRowPolicyNameList();
+            if (s6 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f176(s6);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = input.substr(peg$currPos, 6);
+        if (s1.toLowerCase() === peg$c142) {
+          peg$currPos += (6);
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e151); }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$currPos;
+          peg$silentFails++;
+          s3 = input.charAt(peg$currPos);
+          if (peg$r0.test(s3)) {
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s3 === peg$FAILED) {
+            s2 = undefined;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+          if (s2 !== peg$FAILED) {
+            s3 = peg$parse_();
+            s4 = peg$parseShowCreateAccessKeyword();
+            if (s4 !== peg$FAILED) {
+              s5 = peg$parse_();
+              s6 = peg$parseCreateUserNameList();
+              if (s6 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s0 = peg$f177(s4, s6);
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowRowPolicyKeyword() {
+    let s0, s1, s2, s3, s4, s5, s6;
+
+    const key = peg$currPos * 508 + 112;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 3);
+    if (s1.toLowerCase() === peg$c133) {
+      peg$currPos += (3);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e142); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = input.substr(peg$currPos, 8);
+        if (s4.toLowerCase() === peg$c143) {
+          peg$currPos += (8);
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e152); }
+        }
+        if (s4 === peg$FAILED) {
+          s4 = input.substr(peg$currPos, 6);
+          if (s4.toLowerCase() === peg$c134) {
+            peg$currPos += (6);
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e143); }
+          }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          peg$silentFails++;
+          s6 = input.charAt(peg$currPos);
+          if (peg$r0.test(s6)) {
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s6 === peg$FAILED) {
+            s5 = undefined;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 !== peg$FAILED) {
+            s1 = [s1, s2, s3, s4, s5];
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = input.substr(peg$currPos, 8);
+      if (s1.toLowerCase() === peg$c143) {
+        peg$currPos += (8);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e152); }
+      }
+      if (s1 === peg$FAILED) {
+        s1 = input.substr(peg$currPos, 6);
+        if (s1.toLowerCase() === peg$c134) {
+          peg$currPos += (6);
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e143); }
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r0.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowCreateAccessKeyword() {
+    let s0, s1, s2, s3, s4, s5, s6;
+
+    const key = peg$currPos * 508 + 113;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 5);
+    if (s1.toLowerCase() === peg$c144) {
+      peg$currPos += (5);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e153); }
+    }
+    if (s1 === peg$FAILED) {
+      s1 = input.substr(peg$currPos, 4);
+      if (s1.toLowerCase() === peg$c126) {
+        peg$currPos += (4);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e135); }
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f178();
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = input.substr(peg$currPos, 5);
+      if (s1.toLowerCase() === peg$c145) {
+        peg$currPos += (5);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e154); }
+      }
+      if (s1 === peg$FAILED) {
+        s1 = input.substr(peg$currPos, 4);
+        if (s1.toLowerCase() === peg$c10) {
+          peg$currPos += (4);
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e12); }
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r0.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f179();
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = input.substr(peg$currPos, 6);
+        if (s1.toLowerCase() === peg$c146) {
+          peg$currPos += (6);
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+        }
+        if (s1 === peg$FAILED) {
+          s1 = input.substr(peg$currPos, 5);
+          if (s1.toLowerCase() === peg$c132) {
+            peg$currPos += (5);
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e141); }
+          }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$currPos;
+          peg$silentFails++;
+          s3 = input.charAt(peg$currPos);
+          if (peg$r0.test(s3)) {
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s3 === peg$FAILED) {
+            s2 = undefined;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+          if (s2 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f180();
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = peg$currPos;
+          s2 = input.substr(peg$currPos, 8);
+          if (s2.toLowerCase() === peg$c47) {
+            peg$currPos += (8);
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e51); }
+          }
+          if (s2 !== peg$FAILED) {
+            s3 = peg$currPos;
+            peg$silentFails++;
+            s4 = input.charAt(peg$currPos);
+            if (peg$r0.test(s4)) {
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s4 === peg$FAILED) {
+              s3 = undefined;
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+            if (s3 !== peg$FAILED) {
+              s4 = peg$parse_();
+              s2 = [s2, s3, s4];
+              s1 = s2;
+            } else {
+              peg$currPos = s1;
+              s1 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s1;
+            s1 = peg$FAILED;
+          }
+          if (s1 === peg$FAILED) {
+            s1 = null;
+          }
+          s2 = input.substr(peg$currPos, 8);
+          if (s2.toLowerCase() === peg$c147) {
+            peg$currPos += (8);
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e156); }
+          }
+          if (s2 === peg$FAILED) {
+            s2 = input.substr(peg$currPos, 7);
+            if (s2.toLowerCase() === peg$c140) {
+              peg$currPos += (7);
+            } else {
+              s2 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e149); }
+            }
+          }
+          if (s2 !== peg$FAILED) {
+            s3 = peg$currPos;
+            peg$silentFails++;
+            s4 = input.charAt(peg$currPos);
+            if (peg$r0.test(s4)) {
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s4 === peg$FAILED) {
+              s3 = undefined;
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+            if (s3 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f181();
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            s1 = input.substr(peg$currPos, 5);
+            if (s1.toLowerCase() === peg$c114) {
+              peg$currPos += (5);
+            } else {
+              s1 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e120); }
+            }
+            if (s1 !== peg$FAILED) {
+              s2 = peg$currPos;
+              peg$silentFails++;
+              s3 = input.charAt(peg$currPos);
+              if (peg$r0.test(s3)) {
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s3 === peg$FAILED) {
+                s2 = undefined;
+              } else {
+                peg$currPos = s2;
+                s2 = peg$FAILED;
+              }
+              if (s2 !== peg$FAILED) {
+                s3 = peg$parse_();
+                s4 = input.substr(peg$currPos, 11);
+                if (s4.toLowerCase() === peg$c148) {
+                  peg$currPos += (11);
+                } else {
+                  s4 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e157); }
+                }
+                if (s4 === peg$FAILED) {
+                  s4 = input.substr(peg$currPos, 10);
+                  if (s4.toLowerCase() === peg$c115) {
+                    peg$currPos += (10);
+                  } else {
+                    s4 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e121); }
+                  }
+                }
+                if (s4 !== peg$FAILED) {
+                  s5 = peg$currPos;
+                  peg$silentFails++;
+                  s6 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s6)) {
+                    peg$currPos++;
+                  } else {
+                    s6 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s6 === peg$FAILED) {
+                    s5 = undefined;
+                  } else {
+                    peg$currPos = s5;
+                    s5 = peg$FAILED;
+                  }
+                  if (s5 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s0 = peg$f182();
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          }
+        }
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowColumnsBody() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18;
+
+    const key = peg$currPos * 508 + 114;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$currPos;
+    s2 = input.substr(peg$currPos, 8);
+    if (s2.toLowerCase() === peg$c149) {
+      peg$currPos += (8);
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e158); }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      peg$silentFails++;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r0.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        s2 = [s2, s3, s4];
+        s1 = s2;
+      } else {
+        peg$currPos = s1;
+        s1 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s1;
+      s1 = peg$FAILED;
+    }
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    s2 = peg$currPos;
+    s3 = input.substr(peg$currPos, 4);
+    if (s3.toLowerCase() === peg$c150) {
+      peg$currPos += (4);
+    } else {
+      s3 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e159); }
+    }
+    if (s3 !== peg$FAILED) {
+      s4 = peg$currPos;
+      peg$silentFails++;
+      s5 = input.charAt(peg$currPos);
+      if (peg$r0.test(s5)) {
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s5 === peg$FAILED) {
+        s4 = undefined;
+      } else {
+        peg$currPos = s4;
+        s4 = peg$FAILED;
+      }
+      if (s4 !== peg$FAILED) {
+        s5 = peg$parse_();
+        s3 = [s3, s4, s5];
+        s2 = s3;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s2;
+      s2 = peg$FAILED;
+    }
+    if (s2 === peg$FAILED) {
+      s2 = null;
+    }
+    s3 = peg$currPos;
+    s4 = input.substr(peg$currPos, 7);
+    if (s4.toLowerCase() === peg$c117) {
+      peg$currPos += (7);
+    } else {
+      s4 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e123); }
+    }
+    if (s4 !== peg$FAILED) {
+      peg$savedPos = s3;
+      s4 = peg$f183(s1, s2);
+    }
+    s3 = s4;
+    if (s3 === peg$FAILED) {
+      s3 = peg$currPos;
+      s4 = input.substr(peg$currPos, 6);
+      if (s4.toLowerCase() === peg$c151) {
+        peg$currPos += (6);
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e160); }
+      }
+      if (s4 !== peg$FAILED) {
+        peg$savedPos = s3;
+        s4 = peg$f184(s1, s2);
+      }
+      s3 = s4;
+    }
+    if (s3 !== peg$FAILED) {
+      s4 = peg$currPos;
+      peg$silentFails++;
+      s5 = input.charAt(peg$currPos);
+      if (peg$r0.test(s5)) {
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s5 === peg$FAILED) {
+        s4 = undefined;
+      } else {
+        peg$currPos = s4;
+        s4 = peg$FAILED;
+      }
+      if (s4 !== peg$FAILED) {
+        s5 = peg$parse_();
+        s6 = input.substr(peg$currPos, 4);
+        if (s6.toLowerCase() === peg$c73) {
+          peg$currPos += (4);
+        } else {
+          s6 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e78); }
+        }
+        if (s6 === peg$FAILED) {
+          s6 = input.substr(peg$currPos, 2);
+          if (s6.toLowerCase() === peg$c93) {
+            peg$currPos += (2);
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e98); }
+          }
+        }
+        if (s6 !== peg$FAILED) {
+          s7 = peg$currPos;
+          peg$silentFails++;
+          s8 = input.charAt(peg$currPos);
+          if (peg$r0.test(s8)) {
+            peg$currPos++;
+          } else {
+            s8 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s8 === peg$FAILED) {
+            s7 = undefined;
+          } else {
+            peg$currPos = s7;
+            s7 = peg$FAILED;
+          }
+          if (s7 !== peg$FAILED) {
+            s8 = peg$parse_();
+            s9 = peg$parseTableRef();
+            if (s9 !== peg$FAILED) {
+              s10 = peg$currPos;
+              s11 = peg$parse_();
+              s12 = input.substr(peg$currPos, 4);
+              if (s12.toLowerCase() === peg$c73) {
+                peg$currPos += (4);
+              } else {
+                s12 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e78); }
+              }
+              if (s12 === peg$FAILED) {
+                s12 = input.substr(peg$currPos, 2);
+                if (s12.toLowerCase() === peg$c93) {
+                  peg$currPos += (2);
+                } else {
+                  s12 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e98); }
+                }
+              }
+              if (s12 !== peg$FAILED) {
+                s13 = peg$currPos;
+                peg$silentFails++;
+                s14 = input.charAt(peg$currPos);
+                if (peg$r0.test(s14)) {
+                  peg$currPos++;
+                } else {
+                  s14 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s14 === peg$FAILED) {
+                  s13 = undefined;
+                } else {
+                  peg$currPos = s13;
+                  s13 = peg$FAILED;
+                }
+                if (s13 !== peg$FAILED) {
+                  s14 = peg$parse_();
+                  s15 = peg$parseQueryParamIdentifier();
+                  if (s15 === peg$FAILED) {
+                    s15 = peg$parseAliasName();
+                  }
+                  if (s15 !== peg$FAILED) {
+                    s11 = [s11, s12, s13, s14, s15];
+                    s10 = s11;
+                  } else {
+                    peg$currPos = s10;
+                    s10 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s10;
+                  s10 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s10;
+                s10 = peg$FAILED;
+              }
+              if (s10 === peg$FAILED) {
+                s10 = null;
+              }
+              s11 = peg$currPos;
+              s12 = peg$parse_();
+              s13 = peg$parseShowLikeClause();
+              if (s13 !== peg$FAILED) {
+                s12 = [s12, s13];
+                s11 = s12;
+              } else {
+                peg$currPos = s11;
+                s11 = peg$FAILED;
+              }
+              if (s11 === peg$FAILED) {
+                s11 = null;
+              }
+              s12 = peg$currPos;
+              s13 = peg$parse_();
+              s14 = input.substr(peg$currPos, 5);
+              if (s14.toLowerCase() === peg$c65) {
+                peg$currPos += (5);
+              } else {
+                s14 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e70); }
+              }
+              if (s14 !== peg$FAILED) {
+                s15 = peg$currPos;
+                peg$silentFails++;
+                s16 = input.charAt(peg$currPos);
+                if (peg$r0.test(s16)) {
+                  peg$currPos++;
+                } else {
+                  s16 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s16 === peg$FAILED) {
+                  s15 = undefined;
+                } else {
+                  peg$currPos = s15;
+                  s15 = peg$FAILED;
+                }
+                if (s15 !== peg$FAILED) {
+                  s16 = peg$parse_();
+                  s17 = peg$parseExpression();
+                  if (s17 !== peg$FAILED) {
+                    s13 = [s13, s14, s15, s16, s17];
+                    s12 = s13;
+                  } else {
+                    peg$currPos = s12;
+                    s12 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s12;
+                  s12 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s12;
+                s12 = peg$FAILED;
+              }
+              if (s12 === peg$FAILED) {
+                s12 = null;
+              }
+              s13 = peg$currPos;
+              s14 = peg$parse_();
+              s15 = input.substr(peg$currPos, 5);
+              if (s15.toLowerCase() === peg$c152) {
+                peg$currPos += (5);
+              } else {
+                s15 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e161); }
+              }
+              if (s15 !== peg$FAILED) {
+                s16 = peg$currPos;
+                peg$silentFails++;
+                s17 = input.charAt(peg$currPos);
+                if (peg$r0.test(s17)) {
+                  peg$currPos++;
+                } else {
+                  s17 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s17 === peg$FAILED) {
+                  s16 = undefined;
+                } else {
+                  peg$currPos = s16;
+                  s16 = peg$FAILED;
+                }
+                if (s16 !== peg$FAILED) {
+                  s17 = peg$parse_();
+                  s18 = peg$parseExpression();
+                  if (s18 !== peg$FAILED) {
+                    s14 = [s14, s15, s16, s17, s18];
+                    s13 = s14;
+                  } else {
+                    peg$currPos = s13;
+                    s13 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s13;
+                  s13 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s13;
+                s13 = peg$FAILED;
+              }
+              if (s13 === peg$FAILED) {
+                s13 = null;
+              }
+              peg$savedPos = s0;
+              s0 = peg$f185(s1, s2, s3, s9, s10, s11, s12, s13);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowIndexesBody() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;
+
+    const key = peg$currPos * 508 + 115;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$currPos;
+    s2 = input.substr(peg$currPos, 8);
+    if (s2.toLowerCase() === peg$c149) {
+      peg$currPos += (8);
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e158); }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      peg$silentFails++;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r0.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        s2 = [s2, s3, s4];
+        s1 = s2;
+      } else {
+        peg$currPos = s1;
+        s1 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s1;
+      s1 = peg$FAILED;
+    }
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    s2 = peg$currPos;
+    s3 = input.substr(peg$currPos, 7);
+    if (s3.toLowerCase() === peg$c153) {
+      peg$currPos += (7);
+    } else {
+      s3 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e162); }
+    }
+    if (s3 !== peg$FAILED) {
+      peg$savedPos = s2;
+      s3 = peg$f186(s1);
+    }
+    s2 = s3;
+    if (s2 === peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = input.substr(peg$currPos, 7);
+      if (s3.toLowerCase() === peg$c154) {
+        peg$currPos += (7);
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e163); }
+      }
+      if (s3 !== peg$FAILED) {
+        peg$savedPos = s2;
+        s3 = peg$f187(s1);
+      }
+      s2 = s3;
+      if (s2 === peg$FAILED) {
+        s2 = peg$currPos;
+        s3 = input.substr(peg$currPos, 5);
+        if (s3.toLowerCase() === peg$c58) {
+          peg$currPos += (5);
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e63); }
+        }
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s2;
+          s3 = peg$f188(s1);
+        }
+        s2 = s3;
+        if (s2 === peg$FAILED) {
+          s2 = peg$currPos;
+          s3 = input.substr(peg$currPos, 4);
+          if (s3.toLowerCase() === peg$c155) {
+            peg$currPos += (4);
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e164); }
+          }
+          if (s3 !== peg$FAILED) {
+            peg$savedPos = s2;
+            s3 = peg$f189(s1);
+          }
+          s2 = s3;
+        }
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      peg$silentFails++;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r0.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        s5 = input.substr(peg$currPos, 4);
+        if (s5.toLowerCase() === peg$c73) {
+          peg$currPos += (4);
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e78); }
+        }
+        if (s5 === peg$FAILED) {
+          s5 = input.substr(peg$currPos, 2);
+          if (s5.toLowerCase() === peg$c93) {
+            peg$currPos += (2);
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e98); }
+          }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$currPos;
+          peg$silentFails++;
+          s7 = input.charAt(peg$currPos);
+          if (peg$r0.test(s7)) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s7 === peg$FAILED) {
+            s6 = undefined;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            s7 = peg$parse_();
+            s8 = peg$parseTableRef();
+            if (s8 !== peg$FAILED) {
+              s9 = peg$currPos;
+              s10 = peg$parse_();
+              s11 = input.substr(peg$currPos, 4);
+              if (s11.toLowerCase() === peg$c73) {
+                peg$currPos += (4);
+              } else {
+                s11 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e78); }
+              }
+              if (s11 === peg$FAILED) {
+                s11 = input.substr(peg$currPos, 2);
+                if (s11.toLowerCase() === peg$c93) {
+                  peg$currPos += (2);
+                } else {
+                  s11 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e98); }
+                }
+              }
+              if (s11 !== peg$FAILED) {
+                s12 = peg$currPos;
+                peg$silentFails++;
+                s13 = input.charAt(peg$currPos);
+                if (peg$r0.test(s13)) {
+                  peg$currPos++;
+                } else {
+                  s13 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s13 === peg$FAILED) {
+                  s12 = undefined;
+                } else {
+                  peg$currPos = s12;
+                  s12 = peg$FAILED;
+                }
+                if (s12 !== peg$FAILED) {
+                  s13 = peg$parse_();
+                  s14 = peg$parseQueryParamIdentifier();
+                  if (s14 === peg$FAILED) {
+                    s14 = peg$parseAliasName();
+                  }
+                  if (s14 !== peg$FAILED) {
+                    s10 = [s10, s11, s12, s13, s14];
+                    s9 = s10;
+                  } else {
+                    peg$currPos = s9;
+                    s9 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s9;
+                  s9 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s9;
+                s9 = peg$FAILED;
+              }
+              if (s9 === peg$FAILED) {
+                s9 = null;
+              }
+              s10 = peg$currPos;
+              s11 = peg$parse_();
+              s12 = input.substr(peg$currPos, 5);
+              if (s12.toLowerCase() === peg$c65) {
+                peg$currPos += (5);
+              } else {
+                s12 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e70); }
+              }
+              if (s12 !== peg$FAILED) {
+                s13 = peg$currPos;
+                peg$silentFails++;
+                s14 = input.charAt(peg$currPos);
+                if (peg$r0.test(s14)) {
+                  peg$currPos++;
+                } else {
+                  s14 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s14 === peg$FAILED) {
+                  s13 = undefined;
+                } else {
+                  peg$currPos = s13;
+                  s13 = peg$FAILED;
+                }
+                if (s13 !== peg$FAILED) {
+                  s14 = peg$parse_();
+                  s15 = peg$parseExpression();
+                  if (s15 !== peg$FAILED) {
+                    s11 = [s11, s12, s13, s14, s15];
+                    s10 = s11;
+                  } else {
+                    peg$currPos = s10;
+                    s10 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s10;
+                  s10 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s10;
+                s10 = peg$FAILED;
+              }
+              if (s10 === peg$FAILED) {
+                s10 = null;
+              }
+              peg$savedPos = s0;
+              s0 = peg$f190(s1, s2, s8, s9, s10);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowGrantsBody() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    const key = peg$currPos * 508 + 116;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 6);
+    if (s1.toLowerCase() === peg$c156) {
+      peg$currPos += (6);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e165); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        s5 = input.substr(peg$currPos, 3);
+        if (s5.toLowerCase() === peg$c122) {
+          peg$currPos += (3);
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e128); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$currPos;
+          peg$silentFails++;
+          s7 = input.charAt(peg$currPos);
+          if (peg$r0.test(s7)) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s7 === peg$FAILED) {
+            s6 = undefined;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            s7 = peg$parse_();
+            s8 = peg$parseGranteeList();
+            if (s8 !== peg$FAILED) {
+              s4 = [s4, s5, s6, s7, s8];
+              s3 = s4;
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        s4 = peg$currPos;
+        s5 = peg$parse_();
+        s6 = input.substr(peg$currPos, 4);
+        if (s6.toLowerCase() === peg$c57) {
+          peg$currPos += (4);
+        } else {
+          s6 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e62); }
+        }
+        if (s6 !== peg$FAILED) {
+          s7 = peg$currPos;
+          peg$silentFails++;
+          s8 = input.charAt(peg$currPos);
+          if (peg$r0.test(s8)) {
+            peg$currPos++;
+          } else {
+            s8 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s8 === peg$FAILED) {
+            s7 = undefined;
+          } else {
+            peg$currPos = s7;
+            s7 = peg$FAILED;
+          }
+          if (s7 !== peg$FAILED) {
+            s8 = peg$parse_();
+            s9 = input.substr(peg$currPos, 8);
+            if (s9.toLowerCase() === peg$c157) {
+              peg$currPos += (8);
+            } else {
+              s9 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e166); }
+            }
+            if (s9 !== peg$FAILED) {
+              s10 = peg$currPos;
+              peg$silentFails++;
+              s11 = input.charAt(peg$currPos);
+              if (peg$r0.test(s11)) {
+                peg$currPos++;
+              } else {
+                s11 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s11 === peg$FAILED) {
+                s10 = undefined;
+              } else {
+                peg$currPos = s10;
+                s10 = peg$FAILED;
+              }
+              if (s10 !== peg$FAILED) {
+                s5 = [s5, s6, s7, s8, s9, s10];
+                s4 = s5;
+              } else {
+                peg$currPos = s4;
+                s4 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s4;
+              s4 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+        if (s4 === peg$FAILED) {
+          s4 = null;
+        }
+        s5 = peg$currPos;
+        s6 = peg$parse_();
+        s7 = input.substr(peg$currPos, 5);
+        if (s7.toLowerCase() === peg$c158) {
+          peg$currPos += (5);
+        } else {
+          s7 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e167); }
+        }
+        if (s7 !== peg$FAILED) {
+          s8 = peg$currPos;
+          peg$silentFails++;
+          s9 = input.charAt(peg$currPos);
+          if (peg$r0.test(s9)) {
+            peg$currPos++;
+          } else {
+            s9 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s9 === peg$FAILED) {
+            s8 = undefined;
+          } else {
+            peg$currPos = s8;
+            s8 = peg$FAILED;
+          }
+          if (s8 !== peg$FAILED) {
+            s6 = [s6, s7, s8];
+            s5 = s6;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s5;
+          s5 = peg$FAILED;
+        }
+        if (s5 === peg$FAILED) {
+          s5 = null;
+        }
+        peg$savedPos = s0;
+        s0 = peg$f191(s3, s4, s5);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowListingBody() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
+
+    const key = peg$currPos * 508 + 117;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$currPos;
+    s2 = input.substr(peg$currPos, 9);
+    if (s2.toLowerCase() === peg$c22) {
+      peg$currPos += (9);
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      peg$silentFails++;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r0.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        s2 = [s2, s3, s4];
+        s1 = s2;
+      } else {
+        peg$currPos = s1;
+        s1 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s1;
+      s1 = peg$FAILED;
+    }
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    s2 = peg$currPos;
+    s3 = input.substr(peg$currPos, 6);
+    if (s3.toLowerCase() === peg$c109) {
+      peg$currPos += (6);
+    } else {
+      s3 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e115); }
+    }
+    if (s3 !== peg$FAILED) {
+      peg$savedPos = s2;
+      s3 = peg$f192(s1);
+    }
+    s2 = s3;
+    if (s2 === peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = input.substr(peg$currPos, 9);
+      if (s3.toLowerCase() === peg$c108) {
+        peg$currPos += (9);
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e114); }
+      }
+      if (s3 !== peg$FAILED) {
+        peg$savedPos = s2;
+        s3 = peg$f193(s1);
+      }
+      s2 = s3;
+      if (s2 === peg$FAILED) {
+        s2 = peg$currPos;
+        s3 = input.substr(peg$currPos, 12);
+        if (s3.toLowerCase() === peg$c159) {
+          peg$currPos += (12);
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e168); }
+        }
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s2;
+          s3 = peg$f194(s1);
+        }
+        s2 = s3;
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      peg$silentFails++;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r0.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$currPos;
+        s5 = peg$parse_();
+        s6 = input.substr(peg$currPos, 4);
+        if (s6.toLowerCase() === peg$c73) {
+          peg$currPos += (4);
+        } else {
+          s6 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e78); }
+        }
+        if (s6 === peg$FAILED) {
+          s6 = input.substr(peg$currPos, 2);
+          if (s6.toLowerCase() === peg$c93) {
+            peg$currPos += (2);
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e98); }
+          }
+        }
+        if (s6 !== peg$FAILED) {
+          s7 = peg$currPos;
+          peg$silentFails++;
+          s8 = input.charAt(peg$currPos);
+          if (peg$r0.test(s8)) {
+            peg$currPos++;
+          } else {
+            s8 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s8 === peg$FAILED) {
+            s7 = undefined;
+          } else {
+            peg$currPos = s7;
+            s7 = peg$FAILED;
+          }
+          if (s7 !== peg$FAILED) {
+            s8 = peg$parse_();
+            s9 = peg$parseQueryParamIdentifier();
+            if (s9 === peg$FAILED) {
+              s9 = peg$parseAliasName();
+            }
+            if (s9 !== peg$FAILED) {
+              s5 = [s5, s6, s7, s8, s9];
+              s4 = s5;
+            } else {
+              peg$currPos = s4;
+              s4 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+        if (s4 === peg$FAILED) {
+          s4 = null;
+        }
+        s5 = peg$currPos;
+        s6 = peg$parse_();
+        s7 = peg$parseShowLikeClause();
+        if (s7 !== peg$FAILED) {
+          s6 = [s6, s7];
+          s5 = s6;
+        } else {
+          peg$currPos = s5;
+          s5 = peg$FAILED;
+        }
+        if (s5 === peg$FAILED) {
+          s5 = null;
+        }
+        s6 = peg$currPos;
+        s7 = peg$parse_();
+        s8 = input.substr(peg$currPos, 5);
+        if (s8.toLowerCase() === peg$c65) {
+          peg$currPos += (5);
+        } else {
+          s8 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e70); }
+        }
+        if (s8 !== peg$FAILED) {
+          s9 = peg$currPos;
+          peg$silentFails++;
+          s10 = input.charAt(peg$currPos);
+          if (peg$r0.test(s10)) {
+            peg$currPos++;
+          } else {
+            s10 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s10 === peg$FAILED) {
+            s9 = undefined;
+          } else {
+            peg$currPos = s9;
+            s9 = peg$FAILED;
+          }
+          if (s9 !== peg$FAILED) {
+            s10 = peg$parse_();
+            s11 = peg$parseExpression();
+            if (s11 !== peg$FAILED) {
+              s7 = [s7, s8, s9, s10, s11];
+              s6 = s7;
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s6;
+          s6 = peg$FAILED;
+        }
+        if (s6 === peg$FAILED) {
+          s6 = null;
+        }
+        s7 = peg$currPos;
+        s8 = peg$parse_();
+        s9 = input.substr(peg$currPos, 5);
+        if (s9.toLowerCase() === peg$c152) {
+          peg$currPos += (5);
+        } else {
+          s9 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e161); }
+        }
+        if (s9 !== peg$FAILED) {
+          s10 = peg$currPos;
+          peg$silentFails++;
+          s11 = input.charAt(peg$currPos);
+          if (peg$r0.test(s11)) {
+            peg$currPos++;
+          } else {
+            s11 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s11 === peg$FAILED) {
+            s10 = undefined;
+          } else {
+            peg$currPos = s10;
+            s10 = peg$FAILED;
+          }
+          if (s10 !== peg$FAILED) {
+            s11 = peg$parse_();
+            s12 = peg$parseExpression();
+            if (s12 !== peg$FAILED) {
+              s8 = [s8, s9, s10, s11, s12];
+              s7 = s8;
+            } else {
+              peg$currPos = s7;
+              s7 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s7;
+            s7 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s7;
+          s7 = peg$FAILED;
+        }
+        if (s7 === peg$FAILED) {
+          s7 = null;
+        }
+        s8 = peg$currPos;
+        s9 = peg$parse_();
+        s10 = peg$parseSettingsClause();
+        if (s10 !== peg$FAILED) {
+          s9 = [s9, s10];
+          s8 = s9;
+        } else {
+          peg$currPos = s8;
+          s8 = peg$FAILED;
+        }
+        if (s8 === peg$FAILED) {
+          s8 = null;
+        }
+        peg$savedPos = s0;
+        s0 = peg$f195(s1, s2, s4, s5, s6, s7, s8);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowAccessEntitiesBody() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    const key = peg$currPos * 508 + 118;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$currPos;
+    s2 = input.substr(peg$currPos, 7);
+    if (s2.toLowerCase() === peg$c160) {
+      peg$currPos += (7);
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e169); }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      peg$silentFails++;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r0.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        s2 = [s2, s3, s4];
+        s1 = s2;
+      } else {
+        peg$currPos = s1;
+        s1 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s1;
+      s1 = peg$FAILED;
+    }
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    s2 = input.substr(peg$currPos, 8);
+    if (s2.toLowerCase() === peg$c47) {
+      peg$currPos += (8);
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e51); }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      peg$silentFails++;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r0.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        s5 = input.substr(peg$currPos, 8);
+        if (s5.toLowerCase() === peg$c147) {
+          peg$currPos += (8);
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e156); }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$currPos;
+          peg$silentFails++;
+          s7 = input.charAt(peg$currPos);
+          if (peg$r0.test(s7)) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s7 === peg$FAILED) {
+            s6 = undefined;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f196(s1);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      s2 = input.substr(peg$currPos, 7);
+      if (s2.toLowerCase() === peg$c160) {
+        peg$currPos += (7);
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e169); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$currPos;
+        peg$silentFails++;
+        s4 = input.charAt(peg$currPos);
+        if (peg$r0.test(s4)) {
+          peg$currPos++;
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s4 === peg$FAILED) {
+          s3 = undefined;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parse_();
+          s2 = [s2, s3, s4];
+          s1 = s2;
+        } else {
+          peg$currPos = s1;
+          s1 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s1;
+        s1 = peg$FAILED;
+      }
+      if (s1 === peg$FAILED) {
+        s1 = null;
+      }
+      s2 = input.substr(peg$currPos, 8);
+      if (s2.toLowerCase() === peg$c47) {
+        peg$currPos += (8);
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e51); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$currPos;
+        peg$silentFails++;
+        s4 = input.charAt(peg$currPos);
+        if (peg$r0.test(s4)) {
+          peg$currPos++;
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s4 === peg$FAILED) {
+          s3 = undefined;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = peg$currPos;
+          s5 = peg$parse_();
+          s6 = peg$parseShowLikeClause();
+          if (s6 !== peg$FAILED) {
+            s5 = [s5, s6];
+            s4 = s5;
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+          if (s4 === peg$FAILED) {
+            s4 = null;
+          }
+          s5 = peg$currPos;
+          s6 = peg$parse_();
+          s7 = input.substr(peg$currPos, 7);
+          if (s7.toLowerCase() === peg$c160) {
+            peg$currPos += (7);
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e169); }
+          }
+          if (s7 !== peg$FAILED) {
+            s8 = peg$currPos;
+            peg$silentFails++;
+            s9 = input.charAt(peg$currPos);
+            if (peg$r0.test(s9)) {
+              peg$currPos++;
+            } else {
+              s9 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s9 === peg$FAILED) {
+              s8 = undefined;
+            } else {
+              peg$currPos = s8;
+              s8 = peg$FAILED;
+            }
+            if (s8 !== peg$FAILED) {
+              s6 = [s6, s7, s8];
+              s5 = s6;
+            } else {
+              peg$currPos = s5;
+              s5 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 === peg$FAILED) {
+            s5 = null;
+          }
+          peg$savedPos = s0;
+          s0 = peg$f197(s1, s4, s5);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = input.substr(peg$currPos, 3);
+        if (s1.toLowerCase() === peg$c133) {
+          peg$currPos += (3);
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e142); }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$currPos;
+          peg$silentFails++;
+          s3 = input.charAt(peg$currPos);
+          if (peg$r0.test(s3)) {
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s3 === peg$FAILED) {
+            s2 = undefined;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+          if (s2 !== peg$FAILED) {
+            s3 = peg$parse_();
+            s4 = input.substr(peg$currPos, 8);
+            if (s4.toLowerCase() === peg$c143) {
+              peg$currPos += (8);
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e152); }
+            }
+            if (s4 !== peg$FAILED) {
+              s5 = peg$currPos;
+              peg$silentFails++;
+              s6 = input.charAt(peg$currPos);
+              if (peg$r0.test(s6)) {
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s6 === peg$FAILED) {
+                s5 = undefined;
+              } else {
+                peg$currPos = s5;
+                s5 = peg$FAILED;
+              }
+              if (s5 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s0 = peg$f198();
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = input.substr(peg$currPos, 8);
+          if (s1.toLowerCase() === peg$c143) {
+            peg$currPos += (8);
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e152); }
+          }
+          if (s1 !== peg$FAILED) {
+            s2 = peg$currPos;
+            peg$silentFails++;
+            s3 = input.charAt(peg$currPos);
+            if (peg$r0.test(s3)) {
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s3 === peg$FAILED) {
+              s2 = undefined;
+            } else {
+              peg$currPos = s2;
+              s2 = peg$FAILED;
+            }
+            if (s2 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f199();
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            s1 = input.substr(peg$currPos, 5);
+            if (s1.toLowerCase() === peg$c114) {
+              peg$currPos += (5);
+            } else {
+              s1 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e120); }
+            }
+            if (s1 !== peg$FAILED) {
+              s2 = peg$currPos;
+              peg$silentFails++;
+              s3 = input.charAt(peg$currPos);
+              if (peg$r0.test(s3)) {
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s3 === peg$FAILED) {
+                s2 = undefined;
+              } else {
+                peg$currPos = s2;
+                s2 = peg$FAILED;
+              }
+              if (s2 !== peg$FAILED) {
+                s3 = peg$parse_();
+                s4 = input.substr(peg$currPos, 11);
+                if (s4.toLowerCase() === peg$c148) {
+                  peg$currPos += (11);
+                } else {
+                  s4 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e157); }
+                }
+                if (s4 !== peg$FAILED) {
+                  s5 = peg$currPos;
+                  peg$silentFails++;
+                  s6 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s6)) {
+                    peg$currPos++;
+                  } else {
+                    s6 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s6 === peg$FAILED) {
+                    s5 = undefined;
+                  } else {
+                    peg$currPos = s5;
+                    s5 = peg$FAILED;
+                  }
+                  if (s5 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s0 = peg$f200();
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+            if (s0 === peg$FAILED) {
+              s0 = peg$currPos;
+              s1 = input.substr(peg$currPos, 8);
+              if (s1.toLowerCase() === peg$c147) {
+                peg$currPos += (8);
+              } else {
+                s1 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e156); }
+              }
+              if (s1 !== peg$FAILED) {
+                s2 = peg$currPos;
+                peg$silentFails++;
+                s3 = input.charAt(peg$currPos);
+                if (peg$r0.test(s3)) {
+                  peg$currPos++;
+                } else {
+                  s3 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                }
+                peg$silentFails--;
+                if (s3 === peg$FAILED) {
+                  s2 = undefined;
+                } else {
+                  peg$currPos = s2;
+                  s2 = peg$FAILED;
+                }
+                if (s2 !== peg$FAILED) {
+                  peg$savedPos = s0;
+                  s0 = peg$f201();
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+              if (s0 === peg$FAILED) {
+                s0 = peg$currPos;
+                s1 = input.substr(peg$currPos, 8);
+                if (s1.toLowerCase() === peg$c161) {
+                  peg$currPos += (8);
+                } else {
+                  s1 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e170); }
+                }
+                if (s1 !== peg$FAILED) {
+                  s2 = peg$currPos;
+                  peg$silentFails++;
+                  s3 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s3)) {
+                    peg$currPos++;
+                  } else {
+                    s3 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s3 === peg$FAILED) {
+                    s2 = undefined;
+                  } else {
+                    peg$currPos = s2;
+                    s2 = peg$FAILED;
+                  }
+                  if (s2 !== peg$FAILED) {
+                    s3 = peg$currPos;
+                    s4 = peg$parse_();
+                    s5 = peg$parseShowLikeClause();
+                    if (s5 !== peg$FAILED) {
+                      s4 = [s4, s5];
+                      s3 = s4;
+                    } else {
+                      peg$currPos = s3;
+                      s3 = peg$FAILED;
+                    }
+                    if (s3 === peg$FAILED) {
+                      s3 = null;
+                    }
+                    s4 = peg$currPos;
+                    s5 = peg$parse_();
+                    s6 = input.substr(peg$currPos, 5);
+                    if (s6.toLowerCase() === peg$c152) {
+                      peg$currPos += (5);
+                    } else {
+                      s6 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e161); }
+                    }
+                    if (s6 !== peg$FAILED) {
+                      s7 = peg$currPos;
+                      peg$silentFails++;
+                      s8 = input.charAt(peg$currPos);
+                      if (peg$r0.test(s8)) {
+                        peg$currPos++;
+                      } else {
+                        s8 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                      }
+                      peg$silentFails--;
+                      if (s8 === peg$FAILED) {
+                        s7 = undefined;
+                      } else {
+                        peg$currPos = s7;
+                        s7 = peg$FAILED;
+                      }
+                      if (s7 !== peg$FAILED) {
+                        s8 = peg$parse_();
+                        s9 = peg$parseExpression();
+                        if (s9 !== peg$FAILED) {
+                          s5 = [s5, s6, s7, s8, s9];
+                          s4 = s5;
+                        } else {
+                          peg$currPos = s4;
+                          s4 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s4;
+                        s4 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s4;
+                      s4 = peg$FAILED;
+                    }
+                    if (s4 === peg$FAILED) {
+                      s4 = null;
+                    }
+                    peg$savedPos = s0;
+                    s0 = peg$f202(s3, s4);
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+                if (s0 === peg$FAILED) {
+                  s0 = peg$currPos;
+                  s1 = peg$currPos;
+                  s2 = input.substr(peg$currPos, 7);
+                  if (s2.toLowerCase() === peg$c162) {
+                    peg$currPos += (7);
+                  } else {
+                    s2 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e171); }
+                  }
+                  if (s2 === peg$FAILED) {
+                    s2 = input.substr(peg$currPos, 7);
+                    if (s2.toLowerCase() === peg$c163) {
+                      peg$currPos += (7);
+                    } else {
+                      s2 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e172); }
+                    }
+                  }
+                  if (s2 !== peg$FAILED) {
+                    s3 = peg$currPos;
+                    peg$silentFails++;
+                    s4 = input.charAt(peg$currPos);
+                    if (peg$r0.test(s4)) {
+                      peg$currPos++;
+                    } else {
+                      s4 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                    }
+                    peg$silentFails--;
+                    if (s4 === peg$FAILED) {
+                      s3 = undefined;
+                    } else {
+                      peg$currPos = s3;
+                      s3 = peg$FAILED;
+                    }
+                    if (s3 !== peg$FAILED) {
+                      s4 = peg$parse_();
+                      s2 = [s2, s3, s4];
+                      s1 = s2;
+                    } else {
+                      peg$currPos = s1;
+                      s1 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s1;
+                    s1 = peg$FAILED;
+                  }
+                  if (s1 === peg$FAILED) {
+                    s1 = null;
+                  }
+                  s2 = input.substr(peg$currPos, 5);
+                  if (s2.toLowerCase() === peg$c145) {
+                    peg$currPos += (5);
+                  } else {
+                    s2 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e154); }
+                  }
+                  if (s2 !== peg$FAILED) {
+                    s3 = peg$currPos;
+                    peg$silentFails++;
+                    s4 = input.charAt(peg$currPos);
+                    if (peg$r0.test(s4)) {
+                      peg$currPos++;
+                    } else {
+                      s4 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                    }
+                    peg$silentFails--;
+                    if (s4 === peg$FAILED) {
+                      s3 = undefined;
+                    } else {
+                      peg$currPos = s3;
+                      s3 = peg$FAILED;
+                    }
+                    if (s3 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s0 = peg$f203(s1);
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                  if (s0 === peg$FAILED) {
+                    s0 = peg$currPos;
+                    s1 = input.substr(peg$currPos, 5);
+                    if (s1.toLowerCase() === peg$c144) {
+                      peg$currPos += (5);
+                    } else {
+                      s1 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e153); }
+                    }
+                    if (s1 !== peg$FAILED) {
+                      s2 = peg$currPos;
+                      peg$silentFails++;
+                      s3 = input.charAt(peg$currPos);
+                      if (peg$r0.test(s3)) {
+                        peg$currPos++;
+                      } else {
+                        s3 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                      }
+                      peg$silentFails--;
+                      if (s3 === peg$FAILED) {
+                        s2 = undefined;
+                      } else {
+                        peg$currPos = s2;
+                        s2 = peg$FAILED;
+                      }
+                      if (s2 !== peg$FAILED) {
+                        peg$savedPos = s0;
+                        s0 = peg$f204();
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                    if (s0 === peg$FAILED) {
+                      s0 = peg$currPos;
+                      s1 = input.substr(peg$currPos, 6);
+                      if (s1.toLowerCase() === peg$c146) {
+                        peg$currPos += (6);
+                      } else {
+                        s1 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e155); }
+                      }
+                      if (s1 !== peg$FAILED) {
+                        s2 = peg$currPos;
+                        peg$silentFails++;
+                        s3 = input.charAt(peg$currPos);
+                        if (peg$r0.test(s3)) {
+                          peg$currPos++;
+                        } else {
+                          s3 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                        }
+                        peg$silentFails--;
+                        if (s3 === peg$FAILED) {
+                          s2 = undefined;
+                        } else {
+                          peg$currPos = s2;
+                          s2 = peg$FAILED;
+                        }
+                        if (s2 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s0 = peg$f205();
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                      if (s0 === peg$FAILED) {
+                        s0 = peg$currPos;
+                        s1 = input.substr(peg$currPos, 8);
+                        if (s1.toLowerCase() === peg$c164) {
+                          peg$currPos += (8);
+                        } else {
+                          s1 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$e173); }
+                        }
+                        if (s1 !== peg$FAILED) {
+                          s2 = peg$currPos;
+                          peg$silentFails++;
+                          s3 = input.charAt(peg$currPos);
+                          if (peg$r0.test(s3)) {
+                            peg$currPos++;
+                          } else {
+                            s3 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                          }
+                          peg$silentFails--;
+                          if (s3 === peg$FAILED) {
+                            s2 = undefined;
+                          } else {
+                            peg$currPos = s2;
+                            s2 = peg$FAILED;
+                          }
+                          if (s2 !== peg$FAILED) {
+                            peg$savedPos = s0;
+                            s0 = peg$f206();
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowSettingBody() {
+    let s0, s1, s2, s3, s4;
+
+    const key = peg$currPos * 508 + 119;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 7);
+    if (s1.toLowerCase() === peg$c54) {
+      peg$currPos += (7);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e59); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = peg$parseQueryParamIdentifier();
+        if (s4 === peg$FAILED) {
+          s4 = peg$parseAliasName();
+        }
+        if (s4 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f207(s4);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowSimpleBody() {
+    let s0, s1, s2, s3, s4, s5;
+
+    const key = peg$currPos * 508 + 120;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 10);
+    if (s1.toLowerCase() === peg$c165) {
+      peg$currPos += (10);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e174); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f208();
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = input.substr(peg$currPos, 7);
+      if (s1.toLowerCase() === peg$c166) {
+        peg$currPos += (7);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e175); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r0.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f209();
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = input.substr(peg$currPos, 6);
+        if (s1.toLowerCase() === peg$c167) {
+          peg$currPos += (6);
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e176); }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$currPos;
+          peg$silentFails++;
+          s3 = input.charAt(peg$currPos);
+          if (peg$r0.test(s3)) {
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+          }
+          peg$silentFails--;
+          if (s3 === peg$FAILED) {
+            s2 = undefined;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+          if (s2 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f210();
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = input.substr(peg$currPos, 6);
+          if (s1.toLowerCase() === peg$c168) {
+            peg$currPos += (6);
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e177); }
+          }
+          if (s1 !== peg$FAILED) {
+            s2 = peg$currPos;
+            peg$silentFails++;
+            s3 = input.charAt(peg$currPos);
+            if (peg$r0.test(s3)) {
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e2); }
+            }
+            peg$silentFails--;
+            if (s3 === peg$FAILED) {
+              s2 = undefined;
+            } else {
+              peg$currPos = s2;
+              s2 = peg$FAILED;
+            }
+            if (s2 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f211();
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            s1 = peg$currPos;
+            s2 = input.substr(peg$currPos, 4);
+            if (s2.toLowerCase() === peg$c150) {
+              peg$currPos += (4);
+            } else {
+              s2 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e159); }
+            }
+            if (s2 !== peg$FAILED) {
+              s3 = peg$currPos;
+              peg$silentFails++;
+              s4 = input.charAt(peg$currPos);
+              if (peg$r0.test(s4)) {
+                peg$currPos++;
+              } else {
+                s4 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s4 === peg$FAILED) {
+                s3 = undefined;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
               }
-              if (s6 === peg$FAILED) {
-                s6 = peg$currPos;
-                s7 = peg$currPos;
+              if (s3 !== peg$FAILED) {
+                s4 = peg$parse_();
+                s2 = [s2, s3, s4];
+                s1 = s2;
+              } else {
+                peg$currPos = s1;
+                s1 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s1;
+              s1 = peg$FAILED;
+            }
+            if (s1 === peg$FAILED) {
+              s1 = null;
+            }
+            s2 = input.substr(peg$currPos, 11);
+            if (s2.toLowerCase() === peg$c169) {
+              peg$currPos += (11);
+            } else {
+              s2 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e178); }
+            }
+            if (s2 !== peg$FAILED) {
+              s3 = peg$currPos;
+              peg$silentFails++;
+              s4 = input.charAt(peg$currPos);
+              if (peg$r0.test(s4)) {
+                peg$currPos++;
+              } else {
+                s4 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s4 === peg$FAILED) {
+                s3 = undefined;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+              }
+              if (s3 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s0 = peg$f212(s1);
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+            if (s0 === peg$FAILED) {
+              s0 = peg$currPos;
+              s1 = input.substr(peg$currPos, 9);
+              if (s1.toLowerCase() === peg$c170) {
+                peg$currPos += (9);
+              } else {
+                s1 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e179); }
+              }
+              if (s1 !== peg$FAILED) {
+                s2 = peg$currPos;
                 peg$silentFails++;
-                if (input.charCodeAt(peg$currPos) === 59) {
-                  s8 = peg$c0;
+                s3 = input.charAt(peg$currPos);
+                if (peg$r0.test(s3)) {
                   peg$currPos++;
                 } else {
-                  s8 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e0); }
+                  s3 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
                 }
                 peg$silentFails--;
-                if (s8 === peg$FAILED) {
-                  s7 = undefined;
+                if (s3 === peg$FAILED) {
+                  s2 = undefined;
                 } else {
-                  peg$currPos = s7;
-                  s7 = peg$FAILED;
+                  peg$currPos = s2;
+                  s2 = peg$FAILED;
                 }
-                if (s7 !== peg$FAILED) {
-                  s8 = input.charAt(peg$currPos);
-                  if (peg$r4.test(s8)) {
-                    peg$currPos++;
+                if (s2 !== peg$FAILED) {
+                  s3 = peg$currPos;
+                  s4 = peg$parse_();
+                  s5 = peg$parseShowLikeClause();
+                  if (s5 !== peg$FAILED) {
+                    s4 = [s4, s5];
+                    s3 = s4;
                   } else {
-                    s8 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e117); }
-                  }
-                  if (s8 === peg$FAILED) {
-                    if (input.length > peg$currPos) {
-                      s8 = input.charAt(peg$currPos);
-                      peg$currPos++;
-                    } else {
-                      s8 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e21); }
-                    }
+                    peg$currPos = s3;
+                    s3 = peg$FAILED;
                   }
-                  if (s8 !== peg$FAILED) {
-                    s7 = [s7, s8];
-                    s6 = s7;
-                  } else {
-                    peg$currPos = s6;
-                    s6 = peg$FAILED;
+                  if (s3 === peg$FAILED) {
+                    s3 = null;
                   }
+                  peg$savedPos = s0;
+                  s0 = peg$f213(s3);
                 } else {
-                  peg$currPos = s6;
-                  s6 = peg$FAILED;
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
                 }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
               }
             }
-            s3 = [s3, s4, s5];
-            s2 = s3;
-          } else {
-            peg$currPos = s2;
-            s2 = peg$FAILED;
           }
+        }
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowClusterBody() {
+    let s0, s1, s2, s3, s4;
+
+    const key = peg$currPos * 508 + 121;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = input.substr(peg$currPos, 7);
+    if (s1.toLowerCase() === peg$c139) {
+      peg$currPos += (7);
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e148); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parse_();
+        s4 = peg$parseQueryParamIdentifier();
+        if (s4 === peg$FAILED) {
+          s4 = peg$parseAliasName();
+        }
+        if (s4 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f214(s4);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowObjectShorthandBody() {
+    let s0, s1, s2, s3, s4, s5;
+
+    const key = peg$currPos * 508 + 122;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$currPos;
+    s2 = input.substr(peg$currPos, 9);
+    if (s2.toLowerCase() === peg$c22) {
+      peg$currPos += (9);
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      peg$silentFails++;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r0.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        s2 = [s2, s3, s4];
+        s1 = s2;
+      } else {
+        peg$currPos = s1;
+        s1 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s1;
+      s1 = peg$FAILED;
+    }
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    s2 = peg$currPos;
+    s3 = input.substr(peg$currPos, 5);
+    if (s3.toLowerCase() === peg$c23) {
+      peg$currPos += (5);
+    } else {
+      s3 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e27); }
+    }
+    if (s3 !== peg$FAILED) {
+      peg$savedPos = s2;
+      s3 = peg$f215(s1);
+    }
+    s2 = s3;
+    if (s2 === peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = input.substr(peg$currPos, 4);
+      if (s3.toLowerCase() === peg$c111) {
+        peg$currPos += (4);
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e117); }
+      }
+      if (s3 !== peg$FAILED) {
+        peg$savedPos = s2;
+        s3 = peg$f216(s1);
+      }
+      s2 = s3;
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      peg$silentFails++;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r0.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        s5 = peg$parseTableRef();
+        if (s5 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f217(s1, s2, s5);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = input.substr(peg$currPos, 8);
+      if (s1.toLowerCase() === peg$c112) {
+        peg$currPos += (8);
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e118); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r0.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
         } else {
           peg$currPos = s2;
           s2 = peg$FAILED;
         }
         if (s2 !== peg$FAILED) {
-          s1 = input.substring(s1, peg$currPos);
+          s3 = peg$parse_();
+          s4 = peg$parseQueryParamIdentifier();
+          if (s4 === peg$FAILED) {
+            s4 = peg$parseAliasName();
+          }
+          if (s4 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f218(s4);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
         } else {
-          s1 = s2;
+          peg$currPos = s0;
+          s0 = peg$FAILED;
         }
-        if (s1 !== peg$FAILED) {
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+    return s0;
+  }
+
+  function peg$parseShowLikeClause() {
+    let s0, s1, s2, s3, s4, s5;
+
+    const key = peg$currPos * 508 + 123;
+    const cached = peg$resultsCache[key];
+
+    if (cached) {
+      peg$currPos = cached.nextPos;
+
+      return cached.result;
+    }
+
+    s0 = peg$currPos;
+    s1 = peg$currPos;
+    s2 = input.substr(peg$currPos, 3);
+    if (s2.toLowerCase() === peg$c30) {
+      peg$currPos += (3);
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e34); }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      peg$silentFails++;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r0.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        s2 = [s2, s3, s4];
+        s1 = s2;
+      } else {
+        peg$currPos = s1;
+        s1 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s1;
+      s1 = peg$FAILED;
+    }
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    s2 = peg$currPos;
+    s3 = input.substr(peg$currPos, 5);
+    if (s3.toLowerCase() === peg$c171) {
+      peg$currPos += (5);
+    } else {
+      s3 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e180); }
+    }
+    if (s3 !== peg$FAILED) {
+      peg$savedPos = s2;
+      s3 = peg$f219(s1);
+    }
+    s2 = s3;
+    if (s2 === peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = input.substr(peg$currPos, 4);
+      if (s3.toLowerCase() === peg$c172) {
+        peg$currPos += (4);
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e181); }
+      }
+      if (s3 !== peg$FAILED) {
+        peg$savedPos = s2;
+        s3 = peg$f220(s1);
+      }
+      s2 = s3;
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      peg$silentFails++;
+      s4 = input.charAt(peg$currPos);
+      if (peg$r0.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        s5 = peg$parseStringLiteral();
+        if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f114(s1);
+          s0 = peg$f221(s1, s2, s5);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
         }
-        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
       }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
     }
 
     peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -20460,7 +29875,7 @@ function peg$parse(input, options) {
   function peg$parseDropTargetType() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 82;
+    const key = peg$currPos * 508 + 124;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -20471,11 +29886,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c20) {
+    if (s1.toLowerCase() === peg$c23) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e24); }
+      if (peg$silentFails === 0) { peg$fail(peg$e27); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -20496,7 +29911,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f115();
+        s0 = peg$f222();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -20508,11 +29923,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c112) {
+      if (s1.toLowerCase() === peg$c111) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e118); }
+        if (peg$silentFails === 0) { peg$fail(peg$e117); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -20533,7 +29948,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f116();
+          s0 = peg$f223();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -20545,11 +29960,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 10);
-        if (s1.toLowerCase() === peg$c113) {
+        if (s1.toLowerCase() === peg$c110) {
           peg$currPos += (10);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e119); }
+          if (peg$silentFails === 0) { peg$fail(peg$e116); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -20570,7 +29985,7 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f117();
+            s0 = peg$f224();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -20582,11 +29997,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 8);
-          if (s1.toLowerCase() === peg$c114) {
+          if (s1.toLowerCase() === peg$c112) {
             peg$currPos += (8);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e120); }
+            if (peg$silentFails === 0) { peg$fail(peg$e118); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -20607,7 +30022,7 @@ function peg$parse(input, options) {
             }
             if (s2 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f118();
+              s0 = peg$f225();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -20619,11 +30034,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 8);
-            if (s1.toLowerCase() === peg$c115) {
+            if (s1.toLowerCase() === peg$c113) {
               peg$currPos += (8);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e121); }
+              if (peg$silentFails === 0) { peg$fail(peg$e119); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -20644,7 +30059,7 @@ function peg$parse(input, options) {
               }
               if (s2 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f119();
+                s0 = peg$f226();
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -20666,7 +30081,7 @@ function peg$parse(input, options) {
   function peg$parseInsertStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18;
 
-    const key = peg$currPos * 466 + 83;
+    const key = peg$currPos * 508 + 125;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -20680,11 +30095,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       s3 = input.substr(peg$currPos, 6);
-      if (s3.toLowerCase() === peg$c116) {
+      if (s3.toLowerCase() === peg$c173) {
         peg$currPos += (6);
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e122); }
+        if (peg$silentFails === 0) { peg$fail(peg$e182); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$currPos;
@@ -20736,11 +30151,11 @@ function peg$parse(input, options) {
                 s10 = peg$currPos;
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 9);
-                if (s12.toLowerCase() === peg$c66) {
+                if (s12.toLowerCase() === peg$c70) {
                   peg$currPos += (9);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e71); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e75); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -20762,11 +30177,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 2);
-                    if (s15.toLowerCase() === peg$c80) {
+                    if (s15.toLowerCase() === peg$c84) {
                       peg$currPos += (2);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e85); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e89); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -20856,7 +30271,7 @@ function peg$parse(input, options) {
                 s14 = peg$parseInsertDataClause();
                 if (s14 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f120(s1, s9, s10, s11, s12, s13, s14);
+                  s0 = peg$f227(s1, s9, s10, s11, s12, s13, s14);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -20888,11 +30303,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c116) {
+      if (s1.toLowerCase() === peg$c173) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e122); }
+        if (peg$silentFails === 0) { peg$fail(peg$e182); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -20944,11 +30359,11 @@ function peg$parse(input, options) {
                 s8 = peg$currPos;
                 s9 = peg$parse_();
                 s10 = input.substr(peg$currPos, 9);
-                if (s10.toLowerCase() === peg$c66) {
+                if (s10.toLowerCase() === peg$c70) {
                   peg$currPos += (9);
                 } else {
                   s10 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e71); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e75); }
                 }
                 if (s10 !== peg$FAILED) {
                   s11 = peg$currPos;
@@ -20970,11 +30385,11 @@ function peg$parse(input, options) {
                   if (s11 !== peg$FAILED) {
                     s12 = peg$parse_();
                     s13 = input.substr(peg$currPos, 2);
-                    if (s13.toLowerCase() === peg$c80) {
+                    if (s13.toLowerCase() === peg$c84) {
                       peg$currPos += (2);
                     } else {
                       s13 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e85); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e89); }
                     }
                     if (s13 !== peg$FAILED) {
                       s14 = peg$currPos;
@@ -21064,7 +30479,7 @@ function peg$parse(input, options) {
                 s12 = peg$parseInsertDataClause();
                 if (s12 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f121(s7, s8, s9, s10, s11, s12);
+                  s0 = peg$f228(s7, s8, s9, s10, s11, s12);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -21099,7 +30514,7 @@ function peg$parse(input, options) {
   function peg$parseInsertFromInfileClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 84;
+    const key = peg$currPos * 508 + 126;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -21110,11 +30525,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c69) {
+    if (s1.toLowerCase() === peg$c73) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e74); }
+      if (peg$silentFails === 0) { peg$fail(peg$e78); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -21136,11 +30551,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c117) {
+        if (s4.toLowerCase() === peg$c174) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e123); }
+          if (peg$silentFails === 0) { peg$fail(peg$e183); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -21166,11 +30581,11 @@ function peg$parse(input, options) {
               s8 = peg$currPos;
               s9 = peg$parse_();
               s10 = input.substr(peg$currPos, 11);
-              if (s10.toLowerCase() === peg$c118) {
+              if (s10.toLowerCase() === peg$c175) {
                 peg$currPos += (11);
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e124); }
+                if (peg$silentFails === 0) { peg$fail(peg$e184); }
               }
               if (s10 !== peg$FAILED) {
                 s11 = peg$currPos;
@@ -21194,7 +30609,7 @@ function peg$parse(input, options) {
                   s13 = peg$parseStringLiteral();
                   if (s13 !== peg$FAILED) {
                     peg$savedPos = s8;
-                    s8 = peg$f122(s7, s13);
+                    s8 = peg$f229(s7, s13);
                   } else {
                     peg$currPos = s8;
                     s8 = peg$FAILED;
@@ -21211,7 +30626,7 @@ function peg$parse(input, options) {
                 s8 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f123(s7, s8);
+              s0 = peg$f230(s7, s8);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -21241,7 +30656,7 @@ function peg$parse(input, options) {
   function peg$parseInsertTarget() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 85;
+    const key = peg$currPos * 508 + 127;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -21252,11 +30667,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c20) {
+    if (s1.toLowerCase() === peg$c23) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e24); }
+      if (peg$silentFails === 0) { peg$fail(peg$e27); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -21278,11 +30693,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 8);
-        if (s4.toLowerCase() === peg$c115) {
+        if (s4.toLowerCase() === peg$c113) {
           peg$currPos += (8);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e121); }
+          if (peg$silentFails === 0) { peg$fail(peg$e119); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -21306,7 +30721,7 @@ function peg$parse(input, options) {
             s7 = peg$parseInsertFunctionCall();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f124(s7);
+              s0 = peg$f231(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -21330,11 +30745,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 8);
-      if (s1.toLowerCase() === peg$c115) {
+      if (s1.toLowerCase() === peg$c113) {
         peg$currPos += (8);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e121); }
+        if (peg$silentFails === 0) { peg$fail(peg$e119); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -21358,7 +30773,7 @@ function peg$parse(input, options) {
           s4 = peg$parseInsertFunctionCall();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f125(s4);
+            s0 = peg$f232(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -21374,11 +30789,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 5);
-        if (s1.toLowerCase() === peg$c20) {
+        if (s1.toLowerCase() === peg$c23) {
           peg$currPos += (5);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e24); }
+          if (peg$silentFails === 0) { peg$fail(peg$e27); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -21402,7 +30817,7 @@ function peg$parse(input, options) {
             s4 = peg$parseTableRef();
             if (s4 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f126(s4);
+              s0 = peg$f233(s4);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -21420,7 +30835,7 @@ function peg$parse(input, options) {
           s1 = peg$parseTableRef();
           if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
-            s1 = peg$f127(s1);
+            s1 = peg$f234(s1);
           }
           s0 = s1;
         }
@@ -21435,7 +30850,7 @@ function peg$parse(input, options) {
   function peg$parseInsertFunctionCall() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 86;
+    const key = peg$currPos * 508 + 128;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -21449,11 +30864,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s3 = peg$c21;
+        s3 = peg$c25;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -21463,15 +30878,15 @@ function peg$parse(input, options) {
         }
         s6 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s7 = peg$c22;
+          s7 = peg$c26;
           peg$currPos++;
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s7 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f128(s1, s5);
+          s0 = peg$f235(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -21493,7 +30908,7 @@ function peg$parse(input, options) {
   function peg$parseInsertColumnList() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 87;
+    const key = peg$currPos * 508 + 129;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -21504,11 +30919,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
@@ -21518,11 +30933,11 @@ function peg$parse(input, options) {
         s5 = peg$currPos;
         s6 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s7 = peg$c15;
+          s7 = peg$c24;
           peg$currPos++;
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s7 !== peg$FAILED) {
           s8 = peg$parse_();
@@ -21543,11 +30958,11 @@ function peg$parse(input, options) {
           s5 = peg$currPos;
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s7 = peg$c15;
+            s7 = peg$c24;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$parse_();
@@ -21566,26 +30981,26 @@ function peg$parse(input, options) {
         }
         s5 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s6 = peg$c15;
+          s6 = peg$c24;
           peg$currPos++;
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s6 === peg$FAILED) {
           s6 = null;
         }
         s7 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s8 = peg$c22;
+          s8 = peg$c26;
           peg$currPos++;
         } else {
           s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s8 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f129(s3, s4);
+          s0 = peg$f236(s3, s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -21607,7 +31022,7 @@ function peg$parse(input, options) {
   function peg$parseInsertDataClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 88;
+    const key = peg$currPos * 508 + 130;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -21619,11 +31034,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 6);
-    if (s2.toLowerCase() === peg$c119) {
+    if (s2.toLowerCase() === peg$c176) {
       peg$currPos += (6);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e125); }
+      if (peg$silentFails === 0) { peg$fail(peg$e185); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -21645,7 +31060,7 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parseInsertRawData();
         peg$savedPos = s0;
-        s0 = peg$f130();
+        s0 = peg$f237();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -21658,11 +31073,11 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s1 = peg$parse_();
       s2 = input.substr(peg$currPos, 6);
-      if (s2.toLowerCase() === peg$c120) {
+      if (s2.toLowerCase() === peg$c177) {
         peg$currPos += (6);
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e126); }
+        if (peg$silentFails === 0) { peg$fail(peg$e186); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
@@ -21684,7 +31099,7 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = peg$parseInsertRawData();
           peg$savedPos = s0;
-          s0 = peg$f131();
+          s0 = peg$f238();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -21726,7 +31141,7 @@ function peg$parse(input, options) {
             s4 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f132(s2, s3);
+          s0 = peg$f239(s2, s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -21735,7 +31150,7 @@ function peg$parse(input, options) {
           s0 = peg$currPos;
           s1 = '';
           peg$savedPos = s0;
-          s1 = peg$f133();
+          s1 = peg$f240();
           s0 = s1;
         }
       }
@@ -21749,7 +31164,7 @@ function peg$parse(input, options) {
   function peg$parseInsertRawData() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 89;
+    const key = peg$currPos * 508 + 131;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -21761,47 +31176,47 @@ function peg$parse(input, options) {
     s0 = [];
     s1 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 39) {
-      s2 = peg$c108;
+      s2 = peg$c99;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e113); }
+      if (peg$silentFails === 0) { peg$fail(peg$e104); }
     }
     if (s2 !== peg$FAILED) {
       s3 = [];
-      if (input.substr(peg$currPos, 2) === peg$c109) {
-        s4 = peg$c109;
+      if (input.substr(peg$currPos, 2) === peg$c100) {
+        s4 = peg$c100;
         peg$currPos += 2;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e114); }
+        if (peg$silentFails === 0) { peg$fail(peg$e105); }
       }
       if (s4 === peg$FAILED) {
-        if (input.substr(peg$currPos, 2) === peg$c110) {
-          s4 = peg$c110;
+        if (input.substr(peg$currPos, 2) === peg$c101) {
+          s4 = peg$c101;
           peg$currPos += 2;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e115); }
+          if (peg$silentFails === 0) { peg$fail(peg$e106); }
         }
         if (s4 === peg$FAILED) {
-          if (input.substr(peg$currPos, 2) === peg$c111) {
-            s4 = peg$c111;
+          if (input.substr(peg$currPos, 2) === peg$c102) {
+            s4 = peg$c102;
             peg$currPos += 2;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e116); }
+            if (peg$silentFails === 0) { peg$fail(peg$e107); }
           }
           if (s4 === peg$FAILED) {
             s4 = peg$currPos;
             s5 = peg$currPos;
             peg$silentFails++;
             if (input.charCodeAt(peg$currPos) === 39) {
-              s6 = peg$c108;
+              s6 = peg$c99;
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e113); }
+              if (peg$silentFails === 0) { peg$fail(peg$e104); }
             }
             peg$silentFails--;
             if (s6 === peg$FAILED) {
@@ -21816,7 +31231,7 @@ function peg$parse(input, options) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e117); }
+                if (peg$silentFails === 0) { peg$fail(peg$e108); }
               }
               if (s6 === peg$FAILED) {
                 if (input.length > peg$currPos) {
@@ -21824,7 +31239,7 @@ function peg$parse(input, options) {
                   peg$currPos++;
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e24); }
                 }
               }
               if (s6 !== peg$FAILED) {
@@ -21843,39 +31258,39 @@ function peg$parse(input, options) {
       }
       while (s4 !== peg$FAILED) {
         s3.push(s4);
-        if (input.substr(peg$currPos, 2) === peg$c109) {
-          s4 = peg$c109;
+        if (input.substr(peg$currPos, 2) === peg$c100) {
+          s4 = peg$c100;
           peg$currPos += 2;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e114); }
+          if (peg$silentFails === 0) { peg$fail(peg$e105); }
         }
         if (s4 === peg$FAILED) {
-          if (input.substr(peg$currPos, 2) === peg$c110) {
-            s4 = peg$c110;
+          if (input.substr(peg$currPos, 2) === peg$c101) {
+            s4 = peg$c101;
             peg$currPos += 2;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e115); }
+            if (peg$silentFails === 0) { peg$fail(peg$e106); }
           }
           if (s4 === peg$FAILED) {
-            if (input.substr(peg$currPos, 2) === peg$c111) {
-              s4 = peg$c111;
+            if (input.substr(peg$currPos, 2) === peg$c102) {
+              s4 = peg$c102;
               peg$currPos += 2;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e116); }
+              if (peg$silentFails === 0) { peg$fail(peg$e107); }
             }
             if (s4 === peg$FAILED) {
               s4 = peg$currPos;
               s5 = peg$currPos;
               peg$silentFails++;
               if (input.charCodeAt(peg$currPos) === 39) {
-                s6 = peg$c108;
+                s6 = peg$c99;
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                if (peg$silentFails === 0) { peg$fail(peg$e104); }
               }
               peg$silentFails--;
               if (s6 === peg$FAILED) {
@@ -21890,7 +31305,7 @@ function peg$parse(input, options) {
                   peg$currPos++;
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e117); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e108); }
                 }
                 if (s6 === peg$FAILED) {
                   if (input.length > peg$currPos) {
@@ -21898,7 +31313,7 @@ function peg$parse(input, options) {
                     peg$currPos++;
                   } else {
                     s6 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e24); }
                   }
                 }
                 if (s6 !== peg$FAILED) {
@@ -21917,11 +31332,11 @@ function peg$parse(input, options) {
         }
       }
       if (input.charCodeAt(peg$currPos) === 39) {
-        s4 = peg$c108;
+        s4 = peg$c99;
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e113); }
+        if (peg$silentFails === 0) { peg$fail(peg$e104); }
       }
       if (s4 !== peg$FAILED) {
         s2 = [s2, s3, s4];
@@ -21958,7 +31373,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e117); }
+          if (peg$silentFails === 0) { peg$fail(peg$e108); }
         }
         if (s3 === peg$FAILED) {
           if (input.length > peg$currPos) {
@@ -21966,7 +31381,7 @@ function peg$parse(input, options) {
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e21); }
+            if (peg$silentFails === 0) { peg$fail(peg$e24); }
           }
         }
         if (s3 !== peg$FAILED) {
@@ -21985,47 +31400,47 @@ function peg$parse(input, options) {
       s0.push(s1);
       s1 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 39) {
-        s2 = peg$c108;
+        s2 = peg$c99;
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e113); }
+        if (peg$silentFails === 0) { peg$fail(peg$e104); }
       }
       if (s2 !== peg$FAILED) {
         s3 = [];
-        if (input.substr(peg$currPos, 2) === peg$c109) {
-          s4 = peg$c109;
+        if (input.substr(peg$currPos, 2) === peg$c100) {
+          s4 = peg$c100;
           peg$currPos += 2;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e114); }
+          if (peg$silentFails === 0) { peg$fail(peg$e105); }
         }
         if (s4 === peg$FAILED) {
-          if (input.substr(peg$currPos, 2) === peg$c110) {
-            s4 = peg$c110;
+          if (input.substr(peg$currPos, 2) === peg$c101) {
+            s4 = peg$c101;
             peg$currPos += 2;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e115); }
+            if (peg$silentFails === 0) { peg$fail(peg$e106); }
           }
           if (s4 === peg$FAILED) {
-            if (input.substr(peg$currPos, 2) === peg$c111) {
-              s4 = peg$c111;
+            if (input.substr(peg$currPos, 2) === peg$c102) {
+              s4 = peg$c102;
               peg$currPos += 2;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e116); }
+              if (peg$silentFails === 0) { peg$fail(peg$e107); }
             }
             if (s4 === peg$FAILED) {
               s4 = peg$currPos;
               s5 = peg$currPos;
               peg$silentFails++;
               if (input.charCodeAt(peg$currPos) === 39) {
-                s6 = peg$c108;
+                s6 = peg$c99;
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                if (peg$silentFails === 0) { peg$fail(peg$e104); }
               }
               peg$silentFails--;
               if (s6 === peg$FAILED) {
@@ -22040,7 +31455,7 @@ function peg$parse(input, options) {
                   peg$currPos++;
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e117); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e108); }
                 }
                 if (s6 === peg$FAILED) {
                   if (input.length > peg$currPos) {
@@ -22048,7 +31463,7 @@ function peg$parse(input, options) {
                     peg$currPos++;
                   } else {
                     s6 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e24); }
                   }
                 }
                 if (s6 !== peg$FAILED) {
@@ -22067,39 +31482,39 @@ function peg$parse(input, options) {
         }
         while (s4 !== peg$FAILED) {
           s3.push(s4);
-          if (input.substr(peg$currPos, 2) === peg$c109) {
-            s4 = peg$c109;
+          if (input.substr(peg$currPos, 2) === peg$c100) {
+            s4 = peg$c100;
             peg$currPos += 2;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e114); }
+            if (peg$silentFails === 0) { peg$fail(peg$e105); }
           }
           if (s4 === peg$FAILED) {
-            if (input.substr(peg$currPos, 2) === peg$c110) {
-              s4 = peg$c110;
+            if (input.substr(peg$currPos, 2) === peg$c101) {
+              s4 = peg$c101;
               peg$currPos += 2;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e115); }
+              if (peg$silentFails === 0) { peg$fail(peg$e106); }
             }
             if (s4 === peg$FAILED) {
-              if (input.substr(peg$currPos, 2) === peg$c111) {
-                s4 = peg$c111;
+              if (input.substr(peg$currPos, 2) === peg$c102) {
+                s4 = peg$c102;
                 peg$currPos += 2;
               } else {
                 s4 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e116); }
+                if (peg$silentFails === 0) { peg$fail(peg$e107); }
               }
               if (s4 === peg$FAILED) {
                 s4 = peg$currPos;
                 s5 = peg$currPos;
                 peg$silentFails++;
                 if (input.charCodeAt(peg$currPos) === 39) {
-                  s6 = peg$c108;
+                  s6 = peg$c99;
                   peg$currPos++;
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e104); }
                 }
                 peg$silentFails--;
                 if (s6 === peg$FAILED) {
@@ -22114,7 +31529,7 @@ function peg$parse(input, options) {
                     peg$currPos++;
                   } else {
                     s6 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e117); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e108); }
                   }
                   if (s6 === peg$FAILED) {
                     if (input.length > peg$currPos) {
@@ -22122,7 +31537,7 @@ function peg$parse(input, options) {
                       peg$currPos++;
                     } else {
                       s6 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e24); }
                     }
                   }
                   if (s6 !== peg$FAILED) {
@@ -22141,11 +31556,11 @@ function peg$parse(input, options) {
           }
         }
         if (input.charCodeAt(peg$currPos) === 39) {
-          s4 = peg$c108;
+          s4 = peg$c99;
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e113); }
+          if (peg$silentFails === 0) { peg$fail(peg$e104); }
         }
         if (s4 !== peg$FAILED) {
           s2 = [s2, s3, s4];
@@ -22182,7 +31597,7 @@ function peg$parse(input, options) {
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e117); }
+            if (peg$silentFails === 0) { peg$fail(peg$e108); }
           }
           if (s3 === peg$FAILED) {
             if (input.length > peg$currPos) {
@@ -22190,7 +31605,7 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e21); }
+              if (peg$silentFails === 0) { peg$fail(peg$e24); }
             }
           }
           if (s3 !== peg$FAILED) {
@@ -22215,7 +31630,7 @@ function peg$parse(input, options) {
   function peg$parseParallelWithStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 90;
+    const key = peg$currPos * 508 + 132;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -22231,11 +31646,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       s5 = input.substr(peg$currPos, 8);
-      if (s5.toLowerCase() === peg$c121) {
+      if (s5.toLowerCase() === peg$c178) {
         peg$currPos += (8);
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e127); }
+        if (peg$silentFails === 0) { peg$fail(peg$e187); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$currPos;
@@ -22257,11 +31672,11 @@ function peg$parse(input, options) {
         if (s6 !== peg$FAILED) {
           s7 = peg$parse_();
           s8 = input.substr(peg$currPos, 4);
-          if (s8.toLowerCase() === peg$c53) {
+          if (s8.toLowerCase() === peg$c57) {
             peg$currPos += (4);
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e58); }
+            if (peg$silentFails === 0) { peg$fail(peg$e62); }
           }
           if (s8 !== peg$FAILED) {
             s9 = peg$currPos;
@@ -22312,11 +31727,11 @@ function peg$parse(input, options) {
           s3 = peg$currPos;
           s4 = peg$parse_();
           s5 = input.substr(peg$currPos, 8);
-          if (s5.toLowerCase() === peg$c121) {
+          if (s5.toLowerCase() === peg$c178) {
             peg$currPos += (8);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e127); }
+            if (peg$silentFails === 0) { peg$fail(peg$e187); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$currPos;
@@ -22338,11 +31753,11 @@ function peg$parse(input, options) {
             if (s6 !== peg$FAILED) {
               s7 = peg$parse_();
               s8 = input.substr(peg$currPos, 4);
-              if (s8.toLowerCase() === peg$c53) {
+              if (s8.toLowerCase() === peg$c57) {
                 peg$currPos += (4);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e58); }
+                if (peg$silentFails === 0) { peg$fail(peg$e62); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -22393,7 +31808,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f134(s1, s2);
+        s0 = peg$f241(s1, s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -22410,11 +31825,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 8);
-        if (s5.toLowerCase() === peg$c121) {
+        if (s5.toLowerCase() === peg$c178) {
           peg$currPos += (8);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e127); }
+          if (peg$silentFails === 0) { peg$fail(peg$e187); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -22436,11 +31851,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 4);
-            if (s8.toLowerCase() === peg$c53) {
+            if (s8.toLowerCase() === peg$c57) {
               peg$currPos += (4);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e58); }
+              if (peg$silentFails === 0) { peg$fail(peg$e62); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -22491,11 +31906,11 @@ function peg$parse(input, options) {
             s3 = peg$currPos;
             s4 = peg$parse_();
             s5 = input.substr(peg$currPos, 8);
-            if (s5.toLowerCase() === peg$c121) {
+            if (s5.toLowerCase() === peg$c178) {
               peg$currPos += (8);
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e127); }
+              if (peg$silentFails === 0) { peg$fail(peg$e187); }
             }
             if (s5 !== peg$FAILED) {
               s6 = peg$currPos;
@@ -22517,11 +31932,11 @@ function peg$parse(input, options) {
               if (s6 !== peg$FAILED) {
                 s7 = peg$parse_();
                 s8 = input.substr(peg$currPos, 4);
-                if (s8.toLowerCase() === peg$c53) {
+                if (s8.toLowerCase() === peg$c57) {
                   peg$currPos += (4);
                 } else {
                   s8 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e58); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e62); }
                 }
                 if (s8 !== peg$FAILED) {
                   s9 = peg$currPos;
@@ -22572,7 +31987,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f135(s1, s2);
+          s0 = peg$f242(s1, s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -22591,7 +32006,7 @@ function peg$parse(input, options) {
   function peg$parseParallelWithItem() {
     let s0;
 
-    const key = peg$currPos * 466 + 91;
+    const key = peg$currPos * 508 + 133;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -22604,11 +32019,17 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$parseDropStatement();
       if (s0 === peg$FAILED) {
-        s0 = peg$parseTruncateStatement();
+        s0 = peg$parseUndropStatement();
         if (s0 === peg$FAILED) {
-          s0 = peg$parseOptimizeStatement();
+          s0 = peg$parseBackupStatement();
           if (s0 === peg$FAILED) {
-            s0 = peg$parseAlterStatement();
+            s0 = peg$parseTruncateStatement();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseOptimizeStatement();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parseAlterStatement();
+              }
+            }
           }
         }
       }
@@ -22622,7 +32043,7 @@ function peg$parse(input, options) {
   function peg$parseTruncateStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20;
 
-    const key = peg$currPos * 466 + 92;
+    const key = peg$currPos * 508 + 134;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -22699,11 +32120,11 @@ function peg$parse(input, options) {
         }
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 6);
-        if (s5.toLowerCase() === peg$c122) {
+        if (s5.toLowerCase() === peg$c109) {
           peg$currPos += (6);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e128); }
+          if (peg$silentFails === 0) { peg$fail(peg$e115); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -22725,11 +32146,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 4);
-            if (s8.toLowerCase() === peg$c69) {
+            if (s8.toLowerCase() === peg$c73) {
               peg$currPos += (4);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e74); }
+              if (peg$silentFails === 0) { peg$fail(peg$e78); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -22752,11 +32173,11 @@ function peg$parse(input, options) {
                 s10 = peg$currPos;
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 2);
-                if (s12.toLowerCase() === peg$c25) {
+                if (s12.toLowerCase() === peg$c29) {
                   peg$currPos += (2);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e33); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -22778,11 +32199,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 6);
-                    if (s15.toLowerCase() === peg$c27) {
+                    if (s15.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -22846,11 +32267,11 @@ function peg$parse(input, options) {
                   s15 = peg$parse_();
                   s16 = peg$currPos;
                   s17 = input.substr(peg$currPos, 3);
-                  if (s17.toLowerCase() === peg$c26) {
+                  if (s17.toLowerCase() === peg$c30) {
                     peg$currPos += (3);
                   } else {
                     s17 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e34); }
                   }
                   if (s17 !== peg$FAILED) {
                     s18 = peg$currPos;
@@ -22885,11 +32306,11 @@ function peg$parse(input, options) {
                     s16 = null;
                   }
                   s17 = input.substr(peg$currPos, 4);
-                  if (s17.toLowerCase() === peg$c123) {
+                  if (s17.toLowerCase() === peg$c172) {
                     peg$currPos += (4);
                   } else {
                     s17 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e129); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e181); }
                   }
                   if (s17 !== peg$FAILED) {
                     s18 = peg$currPos;
@@ -22930,7 +32351,7 @@ function peg$parse(input, options) {
                     s14 = null;
                   }
                   peg$savedPos = s0;
-                  s0 = peg$f136(s3, s10, s12, s13, s14);
+                  s0 = peg$f243(s3, s10, s12, s13, s14);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -22988,11 +32409,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 8);
-          if (s4.toLowerCase() === peg$c114) {
+          if (s4.toLowerCase() === peg$c112) {
             peg$currPos += (8);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e120); }
+            if (peg$silentFails === 0) { peg$fail(peg$e118); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -23015,11 +32436,11 @@ function peg$parse(input, options) {
               s6 = peg$currPos;
               s7 = peg$parse_();
               s8 = input.substr(peg$currPos, 2);
-              if (s8.toLowerCase() === peg$c25) {
+              if (s8.toLowerCase() === peg$c29) {
                 peg$currPos += (2);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                if (peg$silentFails === 0) { peg$fail(peg$e33); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -23041,11 +32462,11 @@ function peg$parse(input, options) {
                 if (s9 !== peg$FAILED) {
                   s10 = peg$parse_();
                   s11 = input.substr(peg$currPos, 6);
-                  if (s11.toLowerCase() === peg$c27) {
+                  if (s11.toLowerCase() === peg$c31) {
                     peg$currPos += (6);
                   } else {
                     s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e35); }
                   }
                   if (s11 !== peg$FAILED) {
                     s12 = peg$currPos;
@@ -23106,7 +32527,7 @@ function peg$parse(input, options) {
                   s9 = null;
                 }
                 peg$savedPos = s0;
-                s0 = peg$f137(s6, s8, s9);
+                s0 = peg$f244(s6, s8, s9);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -23157,11 +32578,11 @@ function peg$parse(input, options) {
             s3 = peg$currPos;
             s4 = peg$parse_();
             s5 = input.substr(peg$currPos, 9);
-            if (s5.toLowerCase() === peg$c19) {
+            if (s5.toLowerCase() === peg$c22) {
               peg$currPos += (9);
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e23); }
+              if (peg$silentFails === 0) { peg$fail(peg$e26); }
             }
             if (s5 !== peg$FAILED) {
               s6 = peg$currPos;
@@ -23197,11 +32618,11 @@ function peg$parse(input, options) {
             s4 = peg$currPos;
             s5 = peg$parse_();
             s6 = input.substr(peg$currPos, 5);
-            if (s6.toLowerCase() === peg$c20) {
+            if (s6.toLowerCase() === peg$c23) {
               peg$currPos += (5);
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e24); }
+              if (peg$silentFails === 0) { peg$fail(peg$e27); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$currPos;
@@ -23237,11 +32658,11 @@ function peg$parse(input, options) {
             s5 = peg$currPos;
             s6 = peg$parse_();
             s7 = input.substr(peg$currPos, 2);
-            if (s7.toLowerCase() === peg$c25) {
+            if (s7.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$currPos;
@@ -23263,11 +32684,11 @@ function peg$parse(input, options) {
               if (s8 !== peg$FAILED) {
                 s9 = peg$parse_();
                 s10 = input.substr(peg$currPos, 6);
-                if (s10.toLowerCase() === peg$c27) {
+                if (s10.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s10 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s10 !== peg$FAILED) {
                   s11 = peg$currPos;
@@ -23338,7 +32759,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f138(s3, s5, s7, s8, s9);
+              s0 = peg$f245(s3, s5, s7, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -23362,7 +32783,7 @@ function peg$parse(input, options) {
   function peg$parseOptimizeStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;
 
-    const key = peg$currPos * 466 + 93;
+    const key = peg$currPos * 508 + 135;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -23373,11 +32794,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c124) {
+    if (s1.toLowerCase() === peg$c179) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e130); }
+      if (peg$silentFails === 0) { peg$fail(peg$e188); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -23399,11 +32820,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c20) {
+        if (s4.toLowerCase() === peg$c23) {
           peg$currPos += (5);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e24); }
+          if (peg$silentFails === 0) { peg$fail(peg$e27); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -23446,19 +32867,19 @@ function peg$parse(input, options) {
               s10 = peg$currPos;
               s11 = peg$parse_();
               s12 = input.substr(peg$currPos, 5);
-              if (s12.toLowerCase() === peg$c125) {
+              if (s12.toLowerCase() === peg$c158) {
                 peg$currPos += (5);
               } else {
                 s12 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e131); }
+                if (peg$silentFails === 0) { peg$fail(peg$e167); }
               }
               if (s12 === peg$FAILED) {
                 s12 = input.substr(peg$currPos, 5);
-                if (s12.toLowerCase() === peg$c126) {
+                if (s12.toLowerCase() === peg$c180) {
                   peg$currPos += (5);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e132); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e189); }
                 }
               }
               if (s12 !== peg$FAILED) {
@@ -23495,11 +32916,11 @@ function peg$parse(input, options) {
               s11 = peg$currPos;
               s12 = peg$parse_();
               s13 = input.substr(peg$currPos, 7);
-              if (s13.toLowerCase() === peg$c127) {
+              if (s13.toLowerCase() === peg$c181) {
                 peg$currPos += (7);
               } else {
                 s13 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e133); }
+                if (peg$silentFails === 0) { peg$fail(peg$e190); }
               }
               if (s13 !== peg$FAILED) {
                 s14 = peg$currPos;
@@ -23550,7 +32971,7 @@ function peg$parse(input, options) {
                 s13 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f139(s7, s8, s9, s10, s11, s12, s13);
+              s0 = peg$f246(s7, s8, s9, s10, s11, s12, s13);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -23580,7 +33001,7 @@ function peg$parse(input, options) {
   function peg$parseOptimizePartitionClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 94;
+    const key = peg$currPos * 508 + 136;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -23592,11 +33013,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 9);
-    if (s2.toLowerCase() === peg$c66) {
+    if (s2.toLowerCase() === peg$c70) {
       peg$currPos += (9);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e71); }
+      if (peg$silentFails === 0) { peg$fail(peg$e75); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -23618,11 +33039,11 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c76) {
+        if (s5.toLowerCase() === peg$c80) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e81); }
+          if (peg$silentFails === 0) { peg$fail(peg$e85); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -23646,7 +33067,7 @@ function peg$parse(input, options) {
             s8 = peg$parseStringLiteral();
             if (s8 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f140(s8);
+              s0 = peg$f247(s8);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -23671,11 +33092,11 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s1 = peg$parse_();
       s2 = input.substr(peg$currPos, 9);
-      if (s2.toLowerCase() === peg$c66) {
+      if (s2.toLowerCase() === peg$c70) {
         peg$currPos += (9);
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e71); }
+        if (peg$silentFails === 0) { peg$fail(peg$e75); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
@@ -23722,7 +33143,7 @@ function peg$parse(input, options) {
             }
             if (s6 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f141();
+              s0 = peg$f248();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -23743,11 +33164,11 @@ function peg$parse(input, options) {
         s0 = peg$currPos;
         s1 = peg$parse_();
         s2 = input.substr(peg$currPos, 9);
-        if (s2.toLowerCase() === peg$c66) {
+        if (s2.toLowerCase() === peg$c70) {
           peg$currPos += (9);
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e71); }
+          if (peg$silentFails === 0) { peg$fail(peg$e75); }
         }
         if (s2 !== peg$FAILED) {
           s3 = peg$currPos;
@@ -23771,7 +33192,7 @@ function peg$parse(input, options) {
             s5 = peg$parseExpression();
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f142(s5);
+              s0 = peg$f249(s5);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -23795,7 +33216,7 @@ function peg$parse(input, options) {
   function peg$parseOptimizeDeduplicateClause() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 95;
+    const key = peg$currPos * 508 + 137;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -23807,11 +33228,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 11);
-    if (s2.toLowerCase() === peg$c128) {
+    if (s2.toLowerCase() === peg$c182) {
       peg$currPos += (11);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e134); }
+      if (peg$silentFails === 0) { peg$fail(peg$e191); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -23836,7 +33257,7 @@ function peg$parse(input, options) {
           s4 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f143(s4);
+        s0 = peg$f250(s4);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -23854,7 +33275,7 @@ function peg$parse(input, options) {
   function peg$parseOptimizeDeduplicateByClause() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 96;
+    const key = peg$currPos * 508 + 138;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -23866,11 +33287,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 2);
-    if (s2.toLowerCase() === peg$c80) {
+    if (s2.toLowerCase() === peg$c84) {
       peg$currPos += (2);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e85); }
+      if (peg$silentFails === 0) { peg$fail(peg$e89); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -23894,7 +33315,7 @@ function peg$parse(input, options) {
         s5 = peg$parseExpressionList();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f144(s5);
+          s0 = peg$f251(s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -23916,7 +33337,7 @@ function peg$parse(input, options) {
   function peg$parseDescribeStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 97;
+    const key = peg$currPos * 508 + 139;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -23927,19 +33348,19 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c129) {
+    if (s1.toLowerCase() === peg$c183) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e135); }
+      if (peg$silentFails === 0) { peg$fail(peg$e192); }
     }
     if (s1 === peg$FAILED) {
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c130) {
+      if (s1.toLowerCase() === peg$c184) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e136); }
+        if (peg$silentFails === 0) { peg$fail(peg$e193); }
       }
     }
     if (s1 !== peg$FAILED) {
@@ -23963,11 +33384,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 5);
-        if (s5.toLowerCase() === peg$c20) {
+        if (s5.toLowerCase() === peg$c23) {
           peg$currPos += (5);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e24); }
+          if (peg$silentFails === 0) { peg$fail(peg$e27); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -24006,11 +33427,11 @@ function peg$parse(input, options) {
           s6 = peg$currPos;
           s7 = peg$parse_();
           s8 = input.substr(peg$currPos, 5);
-          if (s8.toLowerCase() === peg$c125) {
+          if (s8.toLowerCase() === peg$c158) {
             peg$currPos += (5);
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e131); }
+            if (peg$silentFails === 0) { peg$fail(peg$e167); }
           }
           if (s8 !== peg$FAILED) {
             s9 = peg$currPos;
@@ -24083,7 +33504,7 @@ function peg$parse(input, options) {
             s9 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f145(s5, s6, s7, s8, s9);
+          s0 = peg$f252(s5, s6, s7, s8, s9);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -24105,7 +33526,7 @@ function peg$parse(input, options) {
   function peg$parseDescribeTarget() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 98;
+    const key = peg$currPos * 508 + 140;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -24116,11 +33537,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
@@ -24128,15 +33549,15 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s5 = peg$c22;
+          s5 = peg$c26;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f146(s3);
+          s0 = peg$f253(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -24155,11 +33576,11 @@ function peg$parse(input, options) {
       peg$silentFails++;
       s2 = peg$currPos;
       s3 = input.substr(peg$currPos, 6);
-      if (s3.toLowerCase() === peg$c131) {
+      if (s3.toLowerCase() === peg$c135) {
         peg$currPos += (6);
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e137); }
+        if (peg$silentFails === 0) { peg$fail(peg$e144); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$currPos;
@@ -24192,11 +33613,11 @@ function peg$parse(input, options) {
       if (s2 === peg$FAILED) {
         s2 = peg$currPos;
         s3 = input.substr(peg$currPos, 4);
-        if (s3.toLowerCase() === peg$c53) {
+        if (s3.toLowerCase() === peg$c57) {
           peg$currPos += (4);
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e58); }
+          if (peg$silentFails === 0) { peg$fail(peg$e62); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$currPos;
@@ -24238,7 +33659,7 @@ function peg$parse(input, options) {
         s2 = peg$parseUnionQuery();
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f147(s2);
+          s0 = peg$f254(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -24252,7 +33673,7 @@ function peg$parse(input, options) {
         s1 = peg$parseTableFunctionRef();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f148(s1);
+          s1 = peg$f255(s1);
         }
         s0 = s1;
         if (s0 === peg$FAILED) {
@@ -24260,7 +33681,7 @@ function peg$parse(input, options) {
           s1 = peg$parseTableRef();
           if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
-            s1 = peg$f149(s1);
+            s1 = peg$f256(s1);
           }
           s0 = s1;
         }
@@ -24275,7 +33696,7 @@ function peg$parse(input, options) {
   function peg$parseShowCreateStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 99;
+    const key = peg$currPos * 508 + 141;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -24286,11 +33707,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c91) {
+    if (s1.toLowerCase() === peg$c141) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e96); }
+      if (peg$silentFails === 0) { peg$fail(peg$e150); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -24312,11 +33733,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c132) {
+        if (s4.toLowerCase() === peg$c142) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e138); }
+          if (peg$silentFails === 0) { peg$fail(peg$e151); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -24378,7 +33799,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f150(s6, s7, s8, s9);
+              s0 = peg$f257(s6, s7, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -24408,7 +33829,7 @@ function peg$parse(input, options) {
   function peg$parseShowCreateTarget() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 100;
+    const key = peg$currPos * 508 + 142;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -24420,11 +33841,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 8);
-    if (s2.toLowerCase() === peg$c114) {
+    if (s2.toLowerCase() === peg$c112) {
       peg$currPos += (8);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e120); }
+      if (peg$silentFails === 0) { peg$fail(peg$e118); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -24451,7 +33872,7 @@ function peg$parse(input, options) {
         }
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f151(s5);
+          s0 = peg$f258(s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -24469,11 +33890,11 @@ function peg$parse(input, options) {
       s1 = peg$currPos;
       s2 = peg$parse_();
       s3 = input.substr(peg$currPos, 9);
-      if (s3.toLowerCase() === peg$c19) {
+      if (s3.toLowerCase() === peg$c22) {
         peg$currPos += (9);
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e23); }
+        if (peg$silentFails === 0) { peg$fail(peg$e26); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$currPos;
@@ -24513,7 +33934,7 @@ function peg$parse(input, options) {
         s5 = peg$parseTableRef();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f152(s3, s5);
+          s0 = peg$f259(s3, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -24526,11 +33947,11 @@ function peg$parse(input, options) {
         s0 = peg$currPos;
         s1 = peg$parse_();
         s2 = input.substr(peg$currPos, 9);
-        if (s2.toLowerCase() === peg$c19) {
+        if (s2.toLowerCase() === peg$c22) {
           peg$currPos += (9);
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e23); }
+          if (peg$silentFails === 0) { peg$fail(peg$e26); }
         }
         if (s2 !== peg$FAILED) {
           s3 = peg$currPos;
@@ -24554,7 +33975,7 @@ function peg$parse(input, options) {
             s5 = peg$parseTableRef();
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f153(s5);
+              s0 = peg$f260(s5);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -24584,7 +34005,7 @@ function peg$parse(input, options) {
             s3 = peg$parseTableRef();
             if (s3 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f154(s3);
+              s0 = peg$f261(s3);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -24605,7 +34026,7 @@ function peg$parse(input, options) {
   function peg$parseShowCreateAccessControlKeyword() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 101;
+    const key = peg$currPos * 508 + 143;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -24616,11 +34037,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c133) {
+    if (s1.toLowerCase() === peg$c126) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e139); }
+      if (peg$silentFails === 0) { peg$fail(peg$e135); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -24690,11 +34111,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 5);
-        if (s1.toLowerCase() === peg$c134) {
+        if (s1.toLowerCase() === peg$c132) {
           peg$currPos += (5);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e140); }
+          if (peg$silentFails === 0) { peg$fail(peg$e141); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -24727,11 +34148,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 3);
-          if (s1.toLowerCase() === peg$c135) {
+          if (s1.toLowerCase() === peg$c133) {
             peg$currPos += (3);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e141); }
+            if (peg$silentFails === 0) { peg$fail(peg$e142); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -24753,11 +34174,11 @@ function peg$parse(input, options) {
             if (s2 !== peg$FAILED) {
               s3 = peg$parse_();
               s4 = input.substr(peg$currPos, 6);
-              if (s4.toLowerCase() === peg$c136) {
+              if (s4.toLowerCase() === peg$c134) {
                 peg$currPos += (6);
               } else {
                 s4 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e142); }
+                if (peg$silentFails === 0) { peg$fail(peg$e143); }
               }
               if (s4 !== peg$FAILED) {
                 s1 = [s1, s2, s3, s4];
@@ -24777,11 +34198,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 6);
-            if (s1.toLowerCase() === peg$c136) {
+            if (s1.toLowerCase() === peg$c134) {
               peg$currPos += (6);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e142); }
+              if (peg$silentFails === 0) { peg$fail(peg$e143); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -24814,11 +34235,11 @@ function peg$parse(input, options) {
             if (s0 === peg$FAILED) {
               s0 = peg$currPos;
               s1 = input.substr(peg$currPos, 8);
-              if (s1.toLowerCase() === peg$c43) {
+              if (s1.toLowerCase() === peg$c47) {
                 peg$currPos += (8);
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                if (peg$silentFails === 0) { peg$fail(peg$e51); }
               }
               if (s1 !== peg$FAILED) {
                 s2 = peg$currPos;
@@ -24840,11 +34261,11 @@ function peg$parse(input, options) {
                 if (s2 !== peg$FAILED) {
                   s3 = peg$parse_();
                   s4 = input.substr(peg$currPos, 7);
-                  if (s4.toLowerCase() === peg$c137) {
+                  if (s4.toLowerCase() === peg$c140) {
                     peg$currPos += (7);
                   } else {
                     s4 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e143); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e149); }
                   }
                   if (s4 !== peg$FAILED) {
                     s1 = [s1, s2, s3, s4];
@@ -24864,11 +34285,11 @@ function peg$parse(input, options) {
               if (s0 === peg$FAILED) {
                 s0 = peg$currPos;
                 s1 = input.substr(peg$currPos, 7);
-                if (s1.toLowerCase() === peg$c137) {
+                if (s1.toLowerCase() === peg$c140) {
                   peg$currPos += (7);
                 } else {
                   s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e143); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e149); }
                 }
                 if (s1 !== peg$FAILED) {
                   s2 = peg$currPos;
@@ -24901,11 +34322,11 @@ function peg$parse(input, options) {
                 if (s0 === peg$FAILED) {
                   s0 = peg$currPos;
                   s1 = input.substr(peg$currPos, 5);
-                  if (s1.toLowerCase() === peg$c138) {
+                  if (s1.toLowerCase() === peg$c114) {
                     peg$currPos += (5);
                   } else {
                     s1 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e144); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e120); }
                   }
                   if (s1 !== peg$FAILED) {
                     s2 = peg$currPos;
@@ -24927,11 +34348,11 @@ function peg$parse(input, options) {
                     if (s2 !== peg$FAILED) {
                       s3 = peg$parse_();
                       s4 = input.substr(peg$currPos, 10);
-                      if (s4.toLowerCase() === peg$c139) {
+                      if (s4.toLowerCase() === peg$c115) {
                         peg$currPos += (10);
                       } else {
                         s4 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e145); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e121); }
                       }
                       if (s4 !== peg$FAILED) {
                         s1 = [s1, s2, s3, s4];
@@ -24951,11 +34372,11 @@ function peg$parse(input, options) {
                   if (s0 === peg$FAILED) {
                     s0 = peg$currPos;
                     s1 = input.substr(peg$currPos, 8);
-                    if (s1.toLowerCase() === peg$c140) {
+                    if (s1.toLowerCase() === peg$c185) {
                       peg$currPos += (8);
                     } else {
                       s1 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e146); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e194); }
                     }
                     if (s1 !== peg$FAILED) {
                       s2 = peg$currPos;
@@ -24988,11 +34409,11 @@ function peg$parse(input, options) {
                     if (s0 === peg$FAILED) {
                       s0 = peg$currPos;
                       s1 = input.substr(peg$currPos, 8);
-                      if (s1.toLowerCase() === peg$c141) {
+                      if (s1.toLowerCase() === peg$c186) {
                         peg$currPos += (8);
                       } else {
                         s1 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e147); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e195); }
                       }
                       if (s1 !== peg$FAILED) {
                         s2 = peg$currPos;
@@ -25040,7 +34461,7 @@ function peg$parse(input, options) {
   function peg$parseShowCreateTargetKeyword() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 102;
+    const key = peg$currPos * 508 + 144;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -25051,11 +34472,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c20) {
+    if (s1.toLowerCase() === peg$c23) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e24); }
+      if (peg$silentFails === 0) { peg$fail(peg$e27); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -25076,7 +34497,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f155();
+        s0 = peg$f262();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -25088,11 +34509,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c112) {
+      if (s1.toLowerCase() === peg$c111) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e118); }
+        if (peg$silentFails === 0) { peg$fail(peg$e117); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -25113,7 +34534,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f156();
+          s0 = peg$f263();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -25125,11 +34546,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 10);
-        if (s1.toLowerCase() === peg$c113) {
+        if (s1.toLowerCase() === peg$c110) {
           peg$currPos += (10);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e119); }
+          if (peg$silentFails === 0) { peg$fail(peg$e116); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -25150,7 +34571,7 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f157();
+            s0 = peg$f264();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -25170,7 +34591,7 @@ function peg$parse(input, options) {
   function peg$parseDetachStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18;
 
-    const key = peg$currPos * 466 + 103;
+    const key = peg$currPos * 508 + 145;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -25181,11 +34602,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c64) {
+    if (s1.toLowerCase() === peg$c68) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e69); }
+      if (peg$silentFails === 0) { peg$fail(peg$e73); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -25207,11 +34628,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 8);
-        if (s4.toLowerCase() === peg$c114) {
+        if (s4.toLowerCase() === peg$c112) {
           peg$currPos += (8);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e120); }
+          if (peg$silentFails === 0) { peg$fail(peg$e118); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -25234,11 +34655,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -25260,11 +34681,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 6);
-                if (s11.toLowerCase() === peg$c27) {
+                if (s11.toLowerCase() === peg$c31) {
                   peg$currPos += (6);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e35); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -25327,11 +34748,11 @@ function peg$parse(input, options) {
               s10 = peg$currPos;
               s11 = peg$parse_();
               s12 = input.substr(peg$currPos, 11);
-              if (s12.toLowerCase() === peg$c142) {
+              if (s12.toLowerCase() === peg$c187) {
                 peg$currPos += (11);
               } else {
                 s12 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e148); }
+                if (peg$silentFails === 0) { peg$fail(peg$e196); }
               }
               if (s12 !== peg$FAILED) {
                 s13 = peg$currPos;
@@ -25367,11 +34788,11 @@ function peg$parse(input, options) {
               s11 = peg$currPos;
               s12 = peg$parse_();
               s13 = input.substr(peg$currPos, 4);
-              if (s13.toLowerCase() === peg$c105) {
+              if (s13.toLowerCase() === peg$c96) {
                 peg$currPos += (4);
               } else {
                 s13 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e110); }
+                if (peg$silentFails === 0) { peg$fail(peg$e101); }
               }
               if (s13 !== peg$FAILED) {
                 s14 = peg$currPos;
@@ -25405,11 +34826,11 @@ function peg$parse(input, options) {
                 s11 = peg$currPos;
                 s12 = peg$parse_();
                 s13 = input.substr(peg$currPos, 2);
-                if (s13.toLowerCase() === peg$c106) {
+                if (s13.toLowerCase() === peg$c97) {
                   peg$currPos += (2);
                 } else {
                   s13 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e111); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e102); }
                 }
                 if (s13 !== peg$FAILED) {
                   s14 = peg$currPos;
@@ -25431,11 +34852,11 @@ function peg$parse(input, options) {
                   if (s14 !== peg$FAILED) {
                     s15 = peg$parse_();
                     s16 = input.substr(peg$currPos, 5);
-                    if (s16.toLowerCase() === peg$c107) {
+                    if (s16.toLowerCase() === peg$c98) {
                       peg$currPos += (5);
                     } else {
                       s16 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e112); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e103); }
                     }
                     if (s16 !== peg$FAILED) {
                       s17 = peg$currPos;
@@ -25489,7 +34910,7 @@ function peg$parse(input, options) {
               }
               if (s12 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f158(s6, s8, s9, s10, s11);
+                s0 = peg$f265(s6, s8, s9, s10, s11);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -25517,11 +34938,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c64) {
+      if (s1.toLowerCase() === peg$c68) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e69); }
+        if (peg$silentFails === 0) { peg$fail(peg$e73); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -25548,11 +34969,11 @@ function peg$parse(input, options) {
           s4 = peg$currPos;
           s5 = peg$parse_();
           s6 = input.substr(peg$currPos, 2);
-          if (s6.toLowerCase() === peg$c25) {
+          if (s6.toLowerCase() === peg$c29) {
             peg$currPos += (2);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e29); }
+            if (peg$silentFails === 0) { peg$fail(peg$e33); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$currPos;
@@ -25574,11 +34995,11 @@ function peg$parse(input, options) {
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
               s9 = input.substr(peg$currPos, 6);
-              if (s9.toLowerCase() === peg$c27) {
+              if (s9.toLowerCase() === peg$c31) {
                 peg$currPos += (6);
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                if (peg$silentFails === 0) { peg$fail(peg$e35); }
               }
               if (s9 !== peg$FAILED) {
                 s10 = peg$currPos;
@@ -25638,11 +35059,11 @@ function peg$parse(input, options) {
             s8 = peg$currPos;
             s9 = peg$parse_();
             s10 = input.substr(peg$currPos, 11);
-            if (s10.toLowerCase() === peg$c142) {
+            if (s10.toLowerCase() === peg$c187) {
               peg$currPos += (11);
             } else {
               s10 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e148); }
+              if (peg$silentFails === 0) { peg$fail(peg$e196); }
             }
             if (s10 !== peg$FAILED) {
               s11 = peg$currPos;
@@ -25678,11 +35099,11 @@ function peg$parse(input, options) {
             s9 = peg$currPos;
             s10 = peg$parse_();
             s11 = input.substr(peg$currPos, 4);
-            if (s11.toLowerCase() === peg$c105) {
+            if (s11.toLowerCase() === peg$c96) {
               peg$currPos += (4);
             } else {
               s11 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e110); }
+              if (peg$silentFails === 0) { peg$fail(peg$e101); }
             }
             if (s11 !== peg$FAILED) {
               s12 = peg$currPos;
@@ -25716,11 +35137,11 @@ function peg$parse(input, options) {
               s9 = peg$currPos;
               s10 = peg$parse_();
               s11 = input.substr(peg$currPos, 2);
-              if (s11.toLowerCase() === peg$c106) {
+              if (s11.toLowerCase() === peg$c97) {
                 peg$currPos += (2);
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e111); }
+                if (peg$silentFails === 0) { peg$fail(peg$e102); }
               }
               if (s11 !== peg$FAILED) {
                 s12 = peg$currPos;
@@ -25742,11 +35163,11 @@ function peg$parse(input, options) {
                 if (s12 !== peg$FAILED) {
                   s13 = peg$parse_();
                   s14 = input.substr(peg$currPos, 5);
-                  if (s14.toLowerCase() === peg$c107) {
+                  if (s14.toLowerCase() === peg$c98) {
                     peg$currPos += (5);
                   } else {
                     s14 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e112); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e103); }
                   }
                   if (s14 !== peg$FAILED) {
                     s15 = peg$currPos;
@@ -25800,7 +35221,7 @@ function peg$parse(input, options) {
             }
             if (s10 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f159(s3, s4, s6, s7, s8, s9);
+              s0 = peg$f266(s3, s4, s6, s7, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -25827,7 +35248,7 @@ function peg$parse(input, options) {
   function peg$parseDetachTableKeyword() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 104;
+    const key = peg$currPos * 508 + 146;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -25840,11 +35261,11 @@ function peg$parse(input, options) {
     s1 = peg$parse_();
     s2 = peg$currPos;
     s3 = input.substr(peg$currPos, 9);
-    if (s3.toLowerCase() === peg$c19) {
+    if (s3.toLowerCase() === peg$c22) {
       peg$currPos += (9);
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e23); }
+      if (peg$silentFails === 0) { peg$fail(peg$e26); }
     }
     if (s3 !== peg$FAILED) {
       s4 = peg$currPos;
@@ -25879,11 +35300,11 @@ function peg$parse(input, options) {
       s2 = null;
     }
     s3 = input.substr(peg$currPos, 5);
-    if (s3.toLowerCase() === peg$c20) {
+    if (s3.toLowerCase() === peg$c23) {
       peg$currPos += (5);
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e24); }
+      if (peg$silentFails === 0) { peg$fail(peg$e27); }
     }
     if (s3 !== peg$FAILED) {
       s4 = peg$currPos;
@@ -25904,7 +35325,7 @@ function peg$parse(input, options) {
       }
       if (s4 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f160();
+        s0 = peg$f267();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -25917,11 +35338,11 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s1 = peg$parse_();
       s2 = input.substr(peg$currPos, 4);
-      if (s2.toLowerCase() === peg$c112) {
+      if (s2.toLowerCase() === peg$c111) {
         peg$currPos += (4);
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e118); }
+        if (peg$silentFails === 0) { peg$fail(peg$e117); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
@@ -25942,7 +35363,7 @@ function peg$parse(input, options) {
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f161();
+          s0 = peg$f268();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -25955,11 +35376,11 @@ function peg$parse(input, options) {
         s0 = peg$currPos;
         s1 = peg$parse_();
         s2 = input.substr(peg$currPos, 10);
-        if (s2.toLowerCase() === peg$c113) {
+        if (s2.toLowerCase() === peg$c110) {
           peg$currPos += (10);
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e119); }
+          if (peg$silentFails === 0) { peg$fail(peg$e116); }
         }
         if (s2 !== peg$FAILED) {
           s3 = peg$currPos;
@@ -25980,7 +35401,7 @@ function peg$parse(input, options) {
           }
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f162();
+            s0 = peg$f269();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -26000,7 +35421,7 @@ function peg$parse(input, options) {
   function peg$parseUpdateStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18;
 
-    const key = peg$currPos * 466 + 105;
+    const key = peg$currPos * 508 + 147;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -26011,11 +35432,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c60) {
+    if (s1.toLowerCase() === peg$c64) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e65); }
+      if (peg$silentFails === 0) { peg$fail(peg$e69); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -26082,11 +35503,11 @@ function peg$parse(input, options) {
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 5);
-                if (s12.toLowerCase() === peg$c61) {
+                if (s12.toLowerCase() === peg$c65) {
                   peg$currPos += (5);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e66); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e70); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -26123,7 +35544,7 @@ function peg$parse(input, options) {
                         s16 = null;
                       }
                       peg$savedPos = s0;
-                      s0 = peg$f163(s4, s5, s10, s15, s16);
+                      s0 = peg$f270(s4, s5, s10, s15, s16);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -26169,7 +35590,7 @@ function peg$parse(input, options) {
   function peg$parseDeleteStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
 
-    const key = peg$currPos * 466 + 106;
+    const key = peg$currPos * 508 + 148;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -26180,11 +35601,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c63) {
+    if (s1.toLowerCase() === peg$c67) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e68); }
+      if (peg$silentFails === 0) { peg$fail(peg$e72); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -26206,11 +35627,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 4);
-        if (s4.toLowerCase() === peg$c69) {
+        if (s4.toLowerCase() === peg$c73) {
           peg$currPos += (4);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e74); }
+          if (peg$silentFails === 0) { peg$fail(peg$e78); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -26252,11 +35673,11 @@ function peg$parse(input, options) {
               }
               s10 = peg$parse_();
               s11 = input.substr(peg$currPos, 5);
-              if (s11.toLowerCase() === peg$c61) {
+              if (s11.toLowerCase() === peg$c65) {
                 peg$currPos += (5);
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e66); }
+                if (peg$silentFails === 0) { peg$fail(peg$e70); }
               }
               if (s11 !== peg$FAILED) {
                 s12 = peg$currPos;
@@ -26293,7 +35714,7 @@ function peg$parse(input, options) {
                       s15 = null;
                     }
                     peg$savedPos = s0;
-                    s0 = peg$f164(s7, s8, s9, s14, s15);
+                    s0 = peg$f271(s7, s8, s9, s14, s15);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -26335,7 +35756,7 @@ function peg$parse(input, options) {
   function peg$parseDeleteInPartitionClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 107;
+    const key = peg$currPos * 508 + 149;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -26347,11 +35768,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 2);
-    if (s2.toLowerCase() === peg$c89) {
+    if (s2.toLowerCase() === peg$c93) {
       peg$currPos += (2);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e94); }
+      if (peg$silentFails === 0) { peg$fail(peg$e98); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -26373,11 +35794,11 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 9);
-        if (s5.toLowerCase() === peg$c66) {
+        if (s5.toLowerCase() === peg$c70) {
           peg$currPos += (9);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e71); }
+          if (peg$silentFails === 0) { peg$fail(peg$e75); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -26399,11 +35820,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c76) {
+            if (s8.toLowerCase() === peg$c80) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e81); }
+              if (peg$silentFails === 0) { peg$fail(peg$e85); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -26427,7 +35848,7 @@ function peg$parse(input, options) {
                 s11 = peg$parseStringLiteral();
                 if (s11 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f165(s11);
+                  s0 = peg$f272(s11);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -26460,11 +35881,11 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s1 = peg$parse_();
       s2 = input.substr(peg$currPos, 2);
-      if (s2.toLowerCase() === peg$c89) {
+      if (s2.toLowerCase() === peg$c93) {
         peg$currPos += (2);
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e94); }
+        if (peg$silentFails === 0) { peg$fail(peg$e98); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
@@ -26486,11 +35907,11 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           s5 = input.substr(peg$currPos, 9);
-          if (s5.toLowerCase() === peg$c66) {
+          if (s5.toLowerCase() === peg$c70) {
             peg$currPos += (9);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e71); }
+            if (peg$silentFails === 0) { peg$fail(peg$e75); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$currPos;
@@ -26514,7 +35935,7 @@ function peg$parse(input, options) {
               s8 = peg$parseExpression();
               if (s8 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f166(s8);
+                s0 = peg$f273(s8);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -26545,7 +35966,7 @@ function peg$parse(input, options) {
   function peg$parseCheckStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 108;
+    const key = peg$currPos * 508 + 150;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -26556,11 +35977,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c55) {
+    if (s1.toLowerCase() === peg$c59) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e60); }
+      if (peg$silentFails === 0) { peg$fail(peg$e64); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -26608,11 +36029,11 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = input.substr(peg$currPos, 6);
-            if (s7.toLowerCase() === peg$c122) {
+            if (s7.toLowerCase() === peg$c109) {
               peg$currPos += (6);
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e128); }
+              if (peg$silentFails === 0) { peg$fail(peg$e115); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$currPos;
@@ -26646,7 +36067,7 @@ function peg$parse(input, options) {
                   s9 = null;
                 }
                 peg$savedPos = s0;
-                s0 = peg$f167(s9);
+                s0 = peg$f274(s9);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -26674,11 +36095,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c55) {
+      if (s1.toLowerCase() === peg$c59) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e60); }
+        if (peg$silentFails === 0) { peg$fail(peg$e64); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -26700,11 +36121,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 8);
-          if (s4.toLowerCase() === peg$c114) {
+          if (s4.toLowerCase() === peg$c112) {
             peg$currPos += (8);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e120); }
+            if (peg$silentFails === 0) { peg$fail(peg$e118); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -26744,7 +36165,7 @@ function peg$parse(input, options) {
                   s8 = null;
                 }
                 peg$savedPos = s0;
-                s0 = peg$f168(s7, s8);
+                s0 = peg$f275(s7, s8);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -26768,11 +36189,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 5);
-        if (s1.toLowerCase() === peg$c55) {
+        if (s1.toLowerCase() === peg$c59) {
           peg$currPos += (5);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e60); }
+          if (peg$silentFails === 0) { peg$fail(peg$e64); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -26795,11 +36216,11 @@ function peg$parse(input, options) {
             s3 = peg$currPos;
             s4 = peg$parse_();
             s5 = input.substr(peg$currPos, 5);
-            if (s5.toLowerCase() === peg$c20) {
+            if (s5.toLowerCase() === peg$c23) {
               peg$currPos += (5);
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e24); }
+              if (peg$silentFails === 0) { peg$fail(peg$e27); }
             }
             if (s5 !== peg$FAILED) {
               s6 = peg$currPos;
@@ -26890,7 +36311,7 @@ function peg$parse(input, options) {
               }
               if (s10 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f169(s5, s6, s7, s8, s9);
+                s0 = peg$f276(s5, s6, s7, s8, s9);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -26918,7 +36339,7 @@ function peg$parse(input, options) {
   function peg$parseCheckPartitionClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 109;
+    const key = peg$currPos * 508 + 151;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -26930,11 +36351,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 9);
-    if (s2.toLowerCase() === peg$c66) {
+    if (s2.toLowerCase() === peg$c70) {
       peg$currPos += (9);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e71); }
+      if (peg$silentFails === 0) { peg$fail(peg$e75); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -26956,11 +36377,11 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c76) {
+        if (s5.toLowerCase() === peg$c80) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e81); }
+          if (peg$silentFails === 0) { peg$fail(peg$e85); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -26984,7 +36405,7 @@ function peg$parse(input, options) {
             s8 = peg$parseStringLiteral();
             if (s8 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f170(s8);
+              s0 = peg$f277(s8);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -27009,11 +36430,11 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s1 = peg$parse_();
       s2 = input.substr(peg$currPos, 9);
-      if (s2.toLowerCase() === peg$c66) {
+      if (s2.toLowerCase() === peg$c70) {
         peg$currPos += (9);
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e71); }
+        if (peg$silentFails === 0) { peg$fail(peg$e75); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
@@ -27037,7 +36458,7 @@ function peg$parse(input, options) {
           s5 = peg$parseExpression();
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f171(s5);
+            s0 = peg$f278(s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -27054,11 +36475,11 @@ function peg$parse(input, options) {
         s0 = peg$currPos;
         s1 = peg$parse_();
         s2 = input.substr(peg$currPos, 4);
-        if (s2.toLowerCase() === peg$c65) {
+        if (s2.toLowerCase() === peg$c69) {
           peg$currPos += (4);
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e70); }
+          if (peg$silentFails === 0) { peg$fail(peg$e74); }
         }
         if (s2 !== peg$FAILED) {
           s3 = peg$currPos;
@@ -27082,7 +36503,7 @@ function peg$parse(input, options) {
             s5 = peg$parseStringLiteral();
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f172(s5);
+              s0 = peg$f279(s5);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -27106,7 +36527,7 @@ function peg$parse(input, options) {
   function peg$parseAttachStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 110;
+    const key = peg$currPos * 508 + 152;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -27117,11 +36538,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c68) {
+    if (s1.toLowerCase() === peg$c72) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e73); }
+      if (peg$silentFails === 0) { peg$fail(peg$e77); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -27143,11 +36564,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 8);
-        if (s4.toLowerCase() === peg$c114) {
+        if (s4.toLowerCase() === peg$c112) {
           peg$currPos += (8);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e120); }
+          if (peg$silentFails === 0) { peg$fail(peg$e118); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -27170,11 +36591,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 2);
-            if (s8.toLowerCase() === peg$c25) {
+            if (s8.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -27196,11 +36617,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 3);
-                if (s11.toLowerCase() === peg$c26) {
+                if (s11.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -27222,11 +36643,11 @@ function peg$parse(input, options) {
                   if (s12 !== peg$FAILED) {
                     s13 = peg$parse_();
                     s14 = input.substr(peg$currPos, 6);
-                    if (s14.toLowerCase() === peg$c27) {
+                    if (s14.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s14 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s14 !== peg$FAILED) {
                       s15 = peg$currPos;
@@ -27306,7 +36727,7 @@ function peg$parse(input, options) {
               }
               if (s10 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f173(s6, s8, s9);
+                s0 = peg$f280(s6, s8, s9);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -27334,11 +36755,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c68) {
+      if (s1.toLowerCase() === peg$c72) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e73); }
+        if (peg$silentFails === 0) { peg$fail(peg$e77); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -27363,11 +36784,11 @@ function peg$parse(input, options) {
             s4 = peg$currPos;
             s5 = peg$parse_();
             s6 = input.substr(peg$currPos, 2);
-            if (s6.toLowerCase() === peg$c25) {
+            if (s6.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$currPos;
@@ -27389,11 +36810,11 @@ function peg$parse(input, options) {
               if (s7 !== peg$FAILED) {
                 s8 = peg$parse_();
                 s9 = input.substr(peg$currPos, 3);
-                if (s9.toLowerCase() === peg$c26) {
+                if (s9.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s9 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s9 !== peg$FAILED) {
                   s10 = peg$currPos;
@@ -27415,11 +36836,11 @@ function peg$parse(input, options) {
                   if (s10 !== peg$FAILED) {
                     s11 = peg$parse_();
                     s12 = input.substr(peg$currPos, 6);
-                    if (s12.toLowerCase() === peg$c27) {
+                    if (s12.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s12 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s12 !== peg$FAILED) {
                       s13 = peg$currPos;
@@ -27474,11 +36895,11 @@ function peg$parse(input, options) {
               s7 = peg$currPos;
               s8 = peg$parse_();
               s9 = input.substr(peg$currPos, 4);
-              if (s9.toLowerCase() === peg$c143) {
+              if (s9.toLowerCase() === peg$c104) {
                 peg$currPos += (4);
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e149); }
+                if (peg$silentFails === 0) { peg$fail(peg$e110); }
               }
               if (s9 !== peg$FAILED) {
                 s10 = peg$currPos;
@@ -27543,7 +36964,7 @@ function peg$parse(input, options) {
               }
               if (s9 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f174(s3, s4, s6, s7, s8);
+                s0 = peg$f281(s3, s4, s6, s7, s8);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -27574,7 +36995,7 @@ function peg$parse(input, options) {
   function peg$parseStatementEnd() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 111;
+    const key = peg$currPos * 508 + 153;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -27600,7 +37021,7 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e21); }
+        if (peg$silentFails === 0) { peg$fail(peg$e24); }
       }
       peg$silentFails--;
       if (s3 === peg$FAILED) {
@@ -27626,7 +37047,7 @@ function peg$parse(input, options) {
   function peg$parseAttachTableKeyword() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 112;
+    const key = peg$currPos * 508 + 154;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -27639,11 +37060,11 @@ function peg$parse(input, options) {
     s1 = peg$parse_();
     s2 = peg$currPos;
     s3 = input.substr(peg$currPos, 9);
-    if (s3.toLowerCase() === peg$c19) {
+    if (s3.toLowerCase() === peg$c22) {
       peg$currPos += (9);
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e23); }
+      if (peg$silentFails === 0) { peg$fail(peg$e26); }
     }
     if (s3 !== peg$FAILED) {
       s4 = peg$currPos;
@@ -27678,11 +37099,11 @@ function peg$parse(input, options) {
       s2 = null;
     }
     s3 = input.substr(peg$currPos, 5);
-    if (s3.toLowerCase() === peg$c20) {
+    if (s3.toLowerCase() === peg$c23) {
       peg$currPos += (5);
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e24); }
+      if (peg$silentFails === 0) { peg$fail(peg$e27); }
     }
     if (s3 !== peg$FAILED) {
       s4 = peg$currPos;
@@ -27703,7 +37124,7 @@ function peg$parse(input, options) {
       }
       if (s4 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f175();
+        s0 = peg$f282();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -27716,11 +37137,11 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s1 = peg$parse_();
       s2 = input.substr(peg$currPos, 4);
-      if (s2.toLowerCase() === peg$c112) {
+      if (s2.toLowerCase() === peg$c111) {
         peg$currPos += (4);
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e118); }
+        if (peg$silentFails === 0) { peg$fail(peg$e117); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
@@ -27741,7 +37162,7 @@ function peg$parse(input, options) {
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f176();
+          s0 = peg$f283();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -27754,11 +37175,11 @@ function peg$parse(input, options) {
         s0 = peg$currPos;
         s1 = peg$parse_();
         s2 = input.substr(peg$currPos, 10);
-        if (s2.toLowerCase() === peg$c113) {
+        if (s2.toLowerCase() === peg$c110) {
           peg$currPos += (10);
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e119); }
+          if (peg$silentFails === 0) { peg$fail(peg$e116); }
         }
         if (s2 !== peg$FAILED) {
           s3 = peg$currPos;
@@ -27779,7 +37200,7 @@ function peg$parse(input, options) {
           }
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f177();
+            s0 = peg$f284();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -27799,7 +37220,7 @@ function peg$parse(input, options) {
   function peg$parseRenameStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 113;
+    const key = peg$currPos * 508 + 155;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -27811,11 +37232,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$currPos;
     s2 = input.substr(peg$currPos, 8);
-    if (s2.toLowerCase() === peg$c90) {
+    if (s2.toLowerCase() === peg$c188) {
       peg$currPos += (8);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e95); }
+      if (peg$silentFails === 0) { peg$fail(peg$e197); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -27836,7 +37257,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s1;
-        s1 = peg$f178();
+        s1 = peg$f285();
       } else {
         peg$currPos = s1;
         s1 = peg$FAILED;
@@ -27848,11 +37269,11 @@ function peg$parse(input, options) {
     if (s1 === peg$FAILED) {
       s1 = peg$currPos;
       s2 = input.substr(peg$currPos, 6);
-      if (s2.toLowerCase() === peg$c51) {
+      if (s2.toLowerCase() === peg$c55) {
         peg$currPos += (6);
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e56); }
+        if (peg$silentFails === 0) { peg$fail(peg$e60); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
@@ -27873,7 +37294,7 @@ function peg$parse(input, options) {
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s1;
-          s1 = peg$f179();
+          s1 = peg$f286();
         } else {
           peg$currPos = s1;
           s1 = peg$FAILED;
@@ -27900,11 +37321,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       s5 = input.substr(peg$currPos, 2);
-      if (s5.toLowerCase() === peg$c25) {
+      if (s5.toLowerCase() === peg$c29) {
         peg$currPos += (2);
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e29); }
+        if (peg$silentFails === 0) { peg$fail(peg$e33); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$currPos;
@@ -27926,11 +37347,11 @@ function peg$parse(input, options) {
         if (s6 !== peg$FAILED) {
           s7 = peg$parse_();
           s8 = input.substr(peg$currPos, 6);
-          if (s8.toLowerCase() === peg$c27) {
+          if (s8.toLowerCase() === peg$c31) {
             peg$currPos += (6);
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e31); }
+            if (peg$silentFails === 0) { peg$fail(peg$e35); }
           }
           if (s8 !== peg$FAILED) {
             s9 = peg$currPos;
@@ -27978,11 +37399,11 @@ function peg$parse(input, options) {
         s7 = peg$currPos;
         s8 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s9 = peg$c15;
+          s9 = peg$c24;
           peg$currPos++;
         } else {
           s9 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s9 !== peg$FAILED) {
           s10 = peg$parse_();
@@ -28003,11 +37424,11 @@ function peg$parse(input, options) {
           s7 = peg$currPos;
           s8 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s9 = peg$c15;
+            s9 = peg$c24;
             peg$currPos++;
           } else {
             s9 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s9 !== peg$FAILED) {
             s10 = peg$parse_();
@@ -28062,7 +37483,7 @@ function peg$parse(input, options) {
         }
         if (s9 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f180(s1, s2, s3, s5, s6, s7, s8);
+          s0 = peg$f287(s1, s2, s3, s5, s6, s7, s8);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -28084,7 +37505,7 @@ function peg$parse(input, options) {
   function peg$parseRenameTargetKeyword() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 114;
+    const key = peg$currPos * 508 + 156;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -28095,11 +37516,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c122) {
+    if (s1.toLowerCase() === peg$c109) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e128); }
+      if (peg$silentFails === 0) { peg$fail(peg$e115); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -28120,7 +37541,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f181();
+        s0 = peg$f288();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -28132,11 +37553,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c20) {
+      if (s1.toLowerCase() === peg$c23) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e24); }
+        if (peg$silentFails === 0) { peg$fail(peg$e27); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -28157,7 +37578,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f182();
+          s0 = peg$f289();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -28169,11 +37590,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 8);
-        if (s1.toLowerCase() === peg$c114) {
+        if (s1.toLowerCase() === peg$c112) {
           peg$currPos += (8);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e120); }
+          if (peg$silentFails === 0) { peg$fail(peg$e118); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -28194,7 +37615,7 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f183();
+            s0 = peg$f290();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -28206,11 +37627,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 12);
-          if (s1.toLowerCase() === peg$c144) {
+          if (s1.toLowerCase() === peg$c159) {
             peg$currPos += (12);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e150); }
+            if (peg$silentFails === 0) { peg$fail(peg$e168); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -28231,7 +37652,7 @@ function peg$parse(input, options) {
             }
             if (s2 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f184();
+              s0 = peg$f291();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -28243,11 +37664,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 10);
-            if (s1.toLowerCase() === peg$c113) {
+            if (s1.toLowerCase() === peg$c110) {
               peg$currPos += (10);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e119); }
+              if (peg$silentFails === 0) { peg$fail(peg$e116); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -28268,7 +37689,7 @@ function peg$parse(input, options) {
               }
               if (s2 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f185();
+                s0 = peg$f292();
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -28290,7 +37711,7 @@ function peg$parse(input, options) {
   function peg$parseRenamePair() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 115;
+    const key = peg$currPos * 508 + 157;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -28312,11 +37733,11 @@ function peg$parse(input, options) {
       }
       if (s3 === peg$FAILED) {
         s3 = input.substr(peg$currPos, 3);
-        if (s3.toLowerCase() === peg$c145) {
+        if (s3.toLowerCase() === peg$c189) {
           peg$currPos += (3);
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e151); }
+          if (peg$silentFails === 0) { peg$fail(peg$e198); }
         }
       }
       if (s3 !== peg$FAILED) {
@@ -28341,7 +37762,7 @@ function peg$parse(input, options) {
           s6 = peg$parseTableRef();
           if (s6 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f186(s1, s6);
+            s0 = peg$f293(s1, s6);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -28367,7 +37788,7 @@ function peg$parse(input, options) {
   function peg$parseKillStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 116;
+    const key = peg$currPos * 508 + 158;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -28378,11 +37799,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c94) {
+    if (s1.toLowerCase() === peg$c190) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e99); }
+      if (peg$silentFails === 0) { peg$fail(peg$e199); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -28405,29 +37826,29 @@ function peg$parse(input, options) {
         s3 = peg$parse_();
         s4 = peg$currPos;
         s5 = input.substr(peg$currPos, 5);
-        if (s5.toLowerCase() === peg$c82) {
+        if (s5.toLowerCase() === peg$c86) {
           peg$currPos += (5);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e87); }
+          if (peg$silentFails === 0) { peg$fail(peg$e91); }
         }
         if (s5 !== peg$FAILED) {
           peg$savedPos = s4;
-          s5 = peg$f187();
+          s5 = peg$f294();
         }
         s4 = s5;
         if (s4 === peg$FAILED) {
           s4 = peg$currPos;
           s5 = input.substr(peg$currPos, 8);
-          if (s5.toLowerCase() === peg$c146) {
+          if (s5.toLowerCase() === peg$c191) {
             peg$currPos += (8);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e152); }
+            if (peg$silentFails === 0) { peg$fail(peg$e200); }
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s4;
-            s5 = peg$f188();
+            s5 = peg$f295();
           }
           s4 = s5;
         }
@@ -28464,11 +37885,11 @@ function peg$parse(input, options) {
             }
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 5);
-            if (s8.toLowerCase() === peg$c61) {
+            if (s8.toLowerCase() === peg$c65) {
               peg$currPos += (5);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e66); }
+              if (peg$silentFails === 0) { peg$fail(peg$e70); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -28494,27 +37915,27 @@ function peg$parse(input, options) {
                   s12 = peg$currPos;
                   s13 = peg$parse_();
                   s14 = input.substr(peg$currPos, 4);
-                  if (s14.toLowerCase() === peg$c105) {
+                  if (s14.toLowerCase() === peg$c96) {
                     peg$currPos += (4);
                   } else {
                     s14 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e110); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e101); }
                   }
                   if (s14 === peg$FAILED) {
                     s14 = input.substr(peg$currPos, 5);
-                    if (s14.toLowerCase() === peg$c147) {
+                    if (s14.toLowerCase() === peg$c107) {
                       peg$currPos += (5);
                     } else {
                       s14 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e153); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e113); }
                     }
                     if (s14 === peg$FAILED) {
                       s14 = input.substr(peg$currPos, 4);
-                      if (s14.toLowerCase() === peg$c148) {
+                      if (s14.toLowerCase() === peg$c192) {
                         peg$currPos += (4);
                       } else {
                         s14 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e154); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e201); }
                       }
                     }
                   }
@@ -28587,7 +38008,7 @@ function peg$parse(input, options) {
                   }
                   if (s15 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f189(s4, s6, s11, s12, s13, s14);
+                    s0 = peg$f296(s4, s6, s11, s12, s13, s14);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -28629,7 +38050,7 @@ function peg$parse(input, options) {
   function peg$parseExistsStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 117;
+    const key = peg$currPos * 508 + 159;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -28640,11 +38061,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c27) {
+    if (s1.toLowerCase() === peg$c31) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+      if (peg$silentFails === 0) { peg$fail(peg$e35); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -28666,11 +38087,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 8);
-        if (s4.toLowerCase() === peg$c114) {
+        if (s4.toLowerCase() === peg$c112) {
           peg$currPos += (8);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e120); }
+          if (peg$silentFails === 0) { peg$fail(peg$e118); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -28710,7 +38131,7 @@ function peg$parse(input, options) {
                 s8 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f190(s7, s8);
+              s0 = peg$f297(s7, s8);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -28734,11 +38155,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c27) {
+      if (s1.toLowerCase() === peg$c31) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e31); }
+        if (peg$silentFails === 0) { peg$fail(peg$e35); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -28761,11 +38182,11 @@ function peg$parse(input, options) {
           s3 = peg$currPos;
           s4 = peg$parse_();
           s5 = input.substr(peg$currPos, 9);
-          if (s5.toLowerCase() === peg$c19) {
+          if (s5.toLowerCase() === peg$c22) {
             peg$currPos += (9);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e23); }
+            if (peg$silentFails === 0) { peg$fail(peg$e26); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$currPos;
@@ -28830,7 +38251,7 @@ function peg$parse(input, options) {
             }
             if (s8 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f191(s4, s6, s7);
+              s0 = peg$f298(s4, s6, s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -28857,7 +38278,7 @@ function peg$parse(input, options) {
   function peg$parseExistsTableKeyword() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 118;
+    const key = peg$currPos * 508 + 160;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -28869,11 +38290,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 5);
-    if (s2.toLowerCase() === peg$c20) {
+    if (s2.toLowerCase() === peg$c23) {
       peg$currPos += (5);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e24); }
+      if (peg$silentFails === 0) { peg$fail(peg$e27); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -28894,7 +38315,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f192();
+        s0 = peg$f299();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -28907,11 +38328,11 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s1 = peg$parse_();
       s2 = input.substr(peg$currPos, 4);
-      if (s2.toLowerCase() === peg$c112) {
+      if (s2.toLowerCase() === peg$c111) {
         peg$currPos += (4);
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e118); }
+        if (peg$silentFails === 0) { peg$fail(peg$e117); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
@@ -28932,7 +38353,7 @@ function peg$parse(input, options) {
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f193();
+          s0 = peg$f300();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -28945,11 +38366,11 @@ function peg$parse(input, options) {
         s0 = peg$currPos;
         s1 = peg$parse_();
         s2 = input.substr(peg$currPos, 10);
-        if (s2.toLowerCase() === peg$c113) {
+        if (s2.toLowerCase() === peg$c110) {
           peg$currPos += (10);
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e119); }
+          if (peg$silentFails === 0) { peg$fail(peg$e116); }
         }
         if (s2 !== peg$FAILED) {
           s3 = peg$currPos;
@@ -28970,7 +38391,7 @@ function peg$parse(input, options) {
           }
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f194();
+            s0 = peg$f301();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -28990,7 +38411,7 @@ function peg$parse(input, options) {
   function peg$parseCreateStatement() {
     let s0;
 
-    const key = peg$currPos * 466 + 119;
+    const key = peg$currPos * 508 + 161;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -29057,7 +38478,7 @@ function peg$parse(input, options) {
   function peg$parseCreateFunctionStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
 
-    const key = peg$currPos * 466 + 120;
+    const key = peg$currPos * 508 + 162;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -29068,11 +38489,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -29095,11 +38516,11 @@ function peg$parse(input, options) {
         s3 = peg$parse_();
         s4 = peg$currPos;
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -29121,11 +38542,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -29168,11 +38589,11 @@ function peg$parse(input, options) {
           s4 = null;
         }
         s5 = input.substr(peg$currPos, 8);
-        if (s5.toLowerCase() === peg$c115) {
+        if (s5.toLowerCase() === peg$c113) {
           peg$currPos += (8);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e121); }
+          if (peg$silentFails === 0) { peg$fail(peg$e119); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -29195,11 +38616,11 @@ function peg$parse(input, options) {
             s7 = peg$currPos;
             s8 = peg$parse_();
             s9 = input.substr(peg$currPos, 2);
-            if (s9.toLowerCase() === peg$c25) {
+            if (s9.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s9 !== peg$FAILED) {
               s10 = peg$currPos;
@@ -29221,11 +38642,11 @@ function peg$parse(input, options) {
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 3);
-                if (s12.toLowerCase() === peg$c26) {
+                if (s12.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -29247,11 +38668,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 6);
-                    if (s15.toLowerCase() === peg$c27) {
+                    if (s15.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -29323,7 +38744,7 @@ function peg$parse(input, options) {
                 s14 = peg$parseExpression();
                 if (s14 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f195(s4, s7, s9, s10, s14);
+                  s0 = peg$f302(s4, s7, s9, s10, s14);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -29361,7 +38782,7 @@ function peg$parse(input, options) {
   function peg$parseCreateViewStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18;
 
-    const key = peg$currPos * 466 + 121;
+    const key = peg$currPos * 508 + 163;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -29372,11 +38793,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -29399,11 +38820,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -29425,11 +38846,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -29473,11 +38894,11 @@ function peg$parse(input, options) {
         s4 = peg$currPos;
         s5 = peg$parse_();
         s6 = input.substr(peg$currPos, 9);
-        if (s6.toLowerCase() === peg$c19) {
+        if (s6.toLowerCase() === peg$c22) {
           peg$currPos += (9);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e23); }
+          if (peg$silentFails === 0) { peg$fail(peg$e26); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -29512,11 +38933,11 @@ function peg$parse(input, options) {
         }
         s5 = peg$parse_();
         s6 = input.substr(peg$currPos, 4);
-        if (s6.toLowerCase() === peg$c112) {
+        if (s6.toLowerCase() === peg$c111) {
           peg$currPos += (4);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e118); }
+          if (peg$silentFails === 0) { peg$fail(peg$e117); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -29539,11 +38960,11 @@ function peg$parse(input, options) {
             s8 = peg$currPos;
             s9 = peg$parse_();
             s10 = input.substr(peg$currPos, 2);
-            if (s10.toLowerCase() === peg$c25) {
+            if (s10.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s10 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s10 !== peg$FAILED) {
               s11 = peg$currPos;
@@ -29565,11 +38986,11 @@ function peg$parse(input, options) {
               if (s11 !== peg$FAILED) {
                 s12 = peg$parse_();
                 s13 = input.substr(peg$currPos, 3);
-                if (s13.toLowerCase() === peg$c26) {
+                if (s13.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s13 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s13 !== peg$FAILED) {
                   s14 = peg$currPos;
@@ -29591,11 +39012,11 @@ function peg$parse(input, options) {
                   if (s14 !== peg$FAILED) {
                     s15 = peg$parse_();
                     s16 = input.substr(peg$currPos, 6);
-                    if (s16.toLowerCase() === peg$c27) {
+                    if (s16.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s16 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s16 !== peg$FAILED) {
                       s17 = peg$currPos;
@@ -29680,7 +39101,7 @@ function peg$parse(input, options) {
                 s16 = peg$parseUnionQuery();
                 if (s16 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f196(s3, s4, s8, s10, s11, s12, s16);
+                  s0 = peg$f303(s3, s4, s8, s10, s11, s12, s16);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -29718,7 +39139,7 @@ function peg$parse(input, options) {
   function peg$parseCreateMaterializedViewStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27, s28, s29;
 
-    const key = peg$currPos * 466 + 122;
+    const key = peg$currPos * 508 + 164;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -29729,19 +39150,19 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 === peg$FAILED) {
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c68) {
+      if (s1.toLowerCase() === peg$c72) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e73); }
+        if (peg$silentFails === 0) { peg$fail(peg$e77); }
       }
     }
     if (s1 !== peg$FAILED) {
@@ -29765,11 +39186,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -29791,11 +39212,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -29838,11 +39259,11 @@ function peg$parse(input, options) {
         }
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 12);
-        if (s5.toLowerCase() === peg$c36) {
+        if (s5.toLowerCase() === peg$c40) {
           peg$currPos += (12);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e40); }
+          if (peg$silentFails === 0) { peg$fail(peg$e44); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -29864,11 +39285,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 4);
-            if (s8.toLowerCase() === peg$c112) {
+            if (s8.toLowerCase() === peg$c111) {
               peg$currPos += (4);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e118); }
+              if (peg$silentFails === 0) { peg$fail(peg$e117); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -29891,11 +39312,11 @@ function peg$parse(input, options) {
                 s10 = peg$currPos;
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 2);
-                if (s12.toLowerCase() === peg$c25) {
+                if (s12.toLowerCase() === peg$c29) {
                   peg$currPos += (2);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e33); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -29917,11 +39338,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 3);
-                    if (s15.toLowerCase() === peg$c26) {
+                    if (s15.toLowerCase() === peg$c30) {
                       peg$currPos += (3);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e34); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -29943,11 +39364,11 @@ function peg$parse(input, options) {
                       if (s16 !== peg$FAILED) {
                         s17 = peg$parse_();
                         s18 = input.substr(peg$currPos, 6);
-                        if (s18.toLowerCase() === peg$c27) {
+                        if (s18.toLowerCase() === peg$c31) {
                           peg$currPos += (6);
                         } else {
                           s18 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e35); }
                         }
                         if (s18 !== peg$FAILED) {
                           s19 = peg$currPos;
@@ -30002,11 +39423,11 @@ function peg$parse(input, options) {
                   s13 = peg$currPos;
                   s14 = peg$parse_();
                   s15 = input.substr(peg$currPos, 4);
-                  if (s15.toLowerCase() === peg$c143) {
+                  if (s15.toLowerCase() === peg$c104) {
                     peg$currPos += (4);
                   } else {
                     s15 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e149); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e110); }
                   }
                   if (s15 !== peg$FAILED) {
                     s16 = peg$currPos;
@@ -30101,11 +39522,11 @@ function peg$parse(input, options) {
                     if (s19 !== peg$FAILED) {
                       s20 = peg$parse_();
                       s21 = input.substr(peg$currPos, 5);
-                      if (s21.toLowerCase() === peg$c150) {
+                      if (s21.toLowerCase() === peg$c194) {
                         peg$currPos += (5);
                       } else {
                         s21 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e156); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e203); }
                       }
                       if (s21 !== peg$FAILED) {
                         s22 = peg$currPos;
@@ -30127,11 +39548,11 @@ function peg$parse(input, options) {
                         if (s22 !== peg$FAILED) {
                           s23 = peg$parse_();
                           s24 = input.substr(peg$currPos, 4);
-                          if (s24.toLowerCase() === peg$c143) {
+                          if (s24.toLowerCase() === peg$c104) {
                             peg$currPos += (4);
                           } else {
                             s24 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e149); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e110); }
                           }
                           if (s24 !== peg$FAILED) {
                             s25 = peg$currPos;
@@ -30264,11 +39685,11 @@ function peg$parse(input, options) {
                   s21 = peg$currPos;
                   s22 = peg$parse_();
                   s23 = input.substr(peg$currPos, 8);
-                  if (s23.toLowerCase() === peg$c151) {
+                  if (s23.toLowerCase() === peg$c195) {
                     peg$currPos += (8);
                   } else {
                     s23 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e157); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e204); }
                   }
                   if (s23 !== peg$FAILED) {
                     s24 = peg$currPos;
@@ -30304,11 +39725,11 @@ function peg$parse(input, options) {
                   s22 = peg$currPos;
                   s23 = peg$parse_();
                   s24 = input.substr(peg$currPos, 5);
-                  if (s24.toLowerCase() === peg$c104) {
+                  if (s24.toLowerCase() === peg$c95) {
                     peg$currPos += (5);
                   } else {
                     s24 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e109); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e100); }
                   }
                   if (s24 !== peg$FAILED) {
                     s25 = peg$currPos;
@@ -30361,7 +39782,7 @@ function peg$parse(input, options) {
                         s27 = null;
                       }
                       peg$savedPos = s0;
-                      s0 = peg$f197(s1, s3, s10, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s26, s27);
+                      s0 = peg$f304(s1, s3, s10, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s26, s27);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -30407,7 +39828,7 @@ function peg$parse(input, options) {
   function peg$parseCreateDatabaseStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
 
-    const key = peg$currPos * 466 + 123;
+    const key = peg$currPos * 508 + 165;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -30418,11 +39839,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -30445,11 +39866,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -30471,11 +39892,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -30518,11 +39939,11 @@ function peg$parse(input, options) {
         }
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 8);
-        if (s5.toLowerCase() === peg$c114) {
+        if (s5.toLowerCase() === peg$c112) {
           peg$currPos += (8);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e120); }
+          if (peg$silentFails === 0) { peg$fail(peg$e118); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -30545,11 +39966,11 @@ function peg$parse(input, options) {
             s7 = peg$currPos;
             s8 = peg$parse_();
             s9 = input.substr(peg$currPos, 2);
-            if (s9.toLowerCase() === peg$c25) {
+            if (s9.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s9 !== peg$FAILED) {
               s10 = peg$currPos;
@@ -30571,11 +39992,11 @@ function peg$parse(input, options) {
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 3);
-                if (s12.toLowerCase() === peg$c26) {
+                if (s12.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -30597,11 +40018,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 6);
-                    if (s15.toLowerCase() === peg$c27) {
+                    if (s15.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -30710,7 +40131,7 @@ function peg$parse(input, options) {
                 s14 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f198(s3, s7, s9, s10, s11, s12, s13, s14);
+              s0 = peg$f305(s3, s7, s9, s10, s11, s12, s13, s14);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -30740,7 +40161,7 @@ function peg$parse(input, options) {
   function peg$parseCreateIndexStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25;
 
-    const key = peg$currPos * 466 + 124;
+    const key = peg$currPos * 508 + 166;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -30751,11 +40172,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -30778,11 +40199,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 6);
-        if (s5.toLowerCase() === peg$c152) {
+        if (s5.toLowerCase() === peg$c196) {
           peg$currPos += (6);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e158); }
+          if (peg$silentFails === 0) { peg$fail(peg$e205); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -30817,11 +40238,11 @@ function peg$parse(input, options) {
         }
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 5);
-        if (s5.toLowerCase() === peg$c54) {
+        if (s5.toLowerCase() === peg$c58) {
           peg$currPos += (5);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e59); }
+          if (peg$silentFails === 0) { peg$fail(peg$e63); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -30844,11 +40265,11 @@ function peg$parse(input, options) {
             s7 = peg$currPos;
             s8 = peg$parse_();
             s9 = input.substr(peg$currPos, 2);
-            if (s9.toLowerCase() === peg$c25) {
+            if (s9.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s9 !== peg$FAILED) {
               s10 = peg$currPos;
@@ -30870,11 +40291,11 @@ function peg$parse(input, options) {
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 3);
-                if (s12.toLowerCase() === peg$c26) {
+                if (s12.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -30896,11 +40317,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 6);
-                    if (s15.toLowerCase() === peg$c27) {
+                    if (s15.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -30954,11 +40375,11 @@ function peg$parse(input, options) {
             if (s9 !== peg$FAILED) {
               s10 = peg$parse_();
               s11 = input.substr(peg$currPos, 2);
-              if (s11.toLowerCase() === peg$c103) {
+              if (s11.toLowerCase() === peg$c94) {
                 peg$currPos += (2);
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e108); }
+                if (peg$silentFails === 0) { peg$fail(peg$e99); }
               }
               if (s11 !== peg$FAILED) {
                 s12 = peg$currPos;
@@ -30987,11 +40408,11 @@ function peg$parse(input, options) {
                       s17 = peg$currPos;
                       s18 = peg$parse_();
                       s19 = input.substr(peg$currPos, 4);
-                      if (s19.toLowerCase() === peg$c33) {
+                      if (s19.toLowerCase() === peg$c37) {
                         peg$currPos += (4);
                       } else {
                         s19 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e37); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e41); }
                       }
                       if (s19 !== peg$FAILED) {
                         s20 = peg$currPos;
@@ -31034,11 +40455,11 @@ function peg$parse(input, options) {
                       s18 = peg$currPos;
                       s19 = peg$parse_();
                       s20 = input.substr(peg$currPos, 11);
-                      if (s20.toLowerCase() === peg$c57) {
+                      if (s20.toLowerCase() === peg$c61) {
                         peg$currPos += (11);
                       } else {
                         s20 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e62); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e66); }
                       }
                       if (s20 !== peg$FAILED) {
                         s21 = peg$currPos;
@@ -31089,7 +40510,7 @@ function peg$parse(input, options) {
                           }
                           if (s23 !== peg$FAILED) {
                             peg$savedPos = s18;
-                            s18 = peg$f199(s3, s7, s9, s14, s16, s17, s23);
+                            s18 = peg$f306(s3, s7, s9, s14, s16, s17, s23);
                           } else {
                             peg$currPos = s18;
                             s18 = peg$FAILED;
@@ -31106,7 +40527,7 @@ function peg$parse(input, options) {
                         s18 = null;
                       }
                       peg$savedPos = s0;
-                      s0 = peg$f200(s3, s7, s9, s14, s16, s17, s18);
+                      s0 = peg$f307(s3, s7, s9, s14, s16, s17, s18);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -31152,7 +40573,7 @@ function peg$parse(input, options) {
   function peg$parseCreateIndexExprs() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 125;
+    const key = peg$currPos * 508 + 167;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -31163,11 +40584,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
@@ -31177,11 +40598,11 @@ function peg$parse(input, options) {
         s5 = peg$currPos;
         s6 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s7 = peg$c15;
+          s7 = peg$c24;
           peg$currPos++;
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s7 !== peg$FAILED) {
           s8 = peg$parse_();
@@ -31202,11 +40623,11 @@ function peg$parse(input, options) {
           s5 = peg$currPos;
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s7 = peg$c15;
+            s7 = peg$c24;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$parse_();
@@ -31225,15 +40646,15 @@ function peg$parse(input, options) {
         }
         s5 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s6 = peg$c22;
+          s6 = peg$c26;
           peg$currPos++;
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s6 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f201(s3, s4);
+          s0 = peg$f308(s3, s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -31251,7 +40672,7 @@ function peg$parse(input, options) {
       s1 = peg$parseTernaryExpr();
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f202(s1);
+        s1 = peg$f309(s1);
       }
       s0 = s1;
     }
@@ -31264,7 +40685,7 @@ function peg$parse(input, options) {
   function peg$parseCreateDictionaryStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18;
 
-    const key = peg$currPos * 466 + 126;
+    const key = peg$currPos * 508 + 168;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -31275,11 +40696,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c70) {
+    if (s1.toLowerCase() === peg$c74) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e75); }
+      if (peg$silentFails === 0) { peg$fail(peg$e79); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -31301,11 +40722,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c113) {
+        if (s4.toLowerCase() === peg$c110) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e119); }
+          if (peg$silentFails === 0) { peg$fail(peg$e116); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -31343,11 +40764,11 @@ function peg$parse(input, options) {
               }
               s9 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 40) {
-                s10 = peg$c21;
+                s10 = peg$c25;
                 peg$currPos++;
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                if (peg$silentFails === 0) { peg$fail(peg$e29); }
               }
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
@@ -31355,18 +40776,18 @@ function peg$parse(input, options) {
                 if (s12 !== peg$FAILED) {
                   s13 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 41) {
-                    s14 = peg$c22;
+                    s14 = peg$c26;
                     peg$currPos++;
                   } else {
                     s14 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
                   }
                   if (s14 !== peg$FAILED) {
                     s15 = peg$parse_();
                     s16 = peg$parseDictDefinition();
                     if (s16 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f203(s7, s8, s12, s16);
+                      s0 = peg$f310(s7, s8, s12, s16);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -31406,11 +40827,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c132) {
+      if (s1.toLowerCase() === peg$c142) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e138); }
+        if (peg$silentFails === 0) { peg$fail(peg$e151); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -31433,11 +40854,11 @@ function peg$parse(input, options) {
           s3 = peg$currPos;
           s4 = peg$parse_();
           s5 = input.substr(peg$currPos, 2);
-          if (s5.toLowerCase() === peg$c149) {
+          if (s5.toLowerCase() === peg$c193) {
             peg$currPos += (2);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e155); }
+            if (peg$silentFails === 0) { peg$fail(peg$e202); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$currPos;
@@ -31459,11 +40880,11 @@ function peg$parse(input, options) {
             if (s6 !== peg$FAILED) {
               s7 = peg$parse_();
               s8 = input.substr(peg$currPos, 7);
-              if (s8.toLowerCase() === peg$c70) {
+              if (s8.toLowerCase() === peg$c74) {
                 peg$currPos += (7);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e75); }
+                if (peg$silentFails === 0) { peg$fail(peg$e79); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -31506,11 +40927,11 @@ function peg$parse(input, options) {
           }
           s4 = peg$parse_();
           s5 = input.substr(peg$currPos, 10);
-          if (s5.toLowerCase() === peg$c113) {
+          if (s5.toLowerCase() === peg$c110) {
             peg$currPos += (10);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e119); }
+            if (peg$silentFails === 0) { peg$fail(peg$e116); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$currPos;
@@ -31533,11 +40954,11 @@ function peg$parse(input, options) {
               s7 = peg$currPos;
               s8 = peg$parse_();
               s9 = input.substr(peg$currPos, 2);
-              if (s9.toLowerCase() === peg$c25) {
+              if (s9.toLowerCase() === peg$c29) {
                 peg$currPos += (2);
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                if (peg$silentFails === 0) { peg$fail(peg$e33); }
               }
               if (s9 !== peg$FAILED) {
                 s10 = peg$currPos;
@@ -31559,11 +40980,11 @@ function peg$parse(input, options) {
                 if (s10 !== peg$FAILED) {
                   s11 = peg$parse_();
                   s12 = input.substr(peg$currPos, 3);
-                  if (s12.toLowerCase() === peg$c26) {
+                  if (s12.toLowerCase() === peg$c30) {
                     peg$currPos += (3);
                   } else {
                     s12 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e34); }
                   }
                   if (s12 !== peg$FAILED) {
                     s13 = peg$currPos;
@@ -31585,11 +41006,11 @@ function peg$parse(input, options) {
                     if (s13 !== peg$FAILED) {
                       s14 = peg$parse_();
                       s15 = input.substr(peg$currPos, 6);
-                      if (s15.toLowerCase() === peg$c27) {
+                      if (s15.toLowerCase() === peg$c31) {
                         peg$currPos += (6);
                       } else {
                         s15 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e35); }
                       }
                       if (s15 !== peg$FAILED) {
                         s16 = peg$currPos;
@@ -31656,11 +41077,11 @@ function peg$parse(input, options) {
                 }
                 s11 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 40) {
-                  s12 = peg$c21;
+                  s12 = peg$c25;
                   peg$currPos++;
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e29); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$parse_();
@@ -31668,18 +41089,18 @@ function peg$parse(input, options) {
                   if (s14 !== peg$FAILED) {
                     s15 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 41) {
-                      s16 = peg$c22;
+                      s16 = peg$c26;
                       peg$currPos++;
                     } else {
                       s16 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e30); }
                     }
                     if (s16 !== peg$FAILED) {
                       s17 = peg$parse_();
                       s18 = peg$parseDictDefinition();
                       if (s18 !== peg$FAILED) {
                         peg$savedPos = s0;
-                        s0 = peg$f204(s3, s7, s9, s10, s14, s18);
+                        s0 = peg$f311(s3, s7, s9, s10, s14, s18);
                       } else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
@@ -31726,7 +41147,7 @@ function peg$parse(input, options) {
   function peg$parseDictAttrList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 127;
+    const key = peg$currPos * 508 + 169;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -31742,11 +41163,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -31767,11 +41188,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -31791,11 +41212,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s4 = [s4, s5];
@@ -31808,7 +41229,7 @@ function peg$parse(input, options) {
         s3 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f205(s1, s2);
+      s0 = peg$f312(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -31822,7 +41243,7 @@ function peg$parse(input, options) {
   function peg$parseDictAttr() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 128;
+    const key = peg$currPos * 508 + 170;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -31887,11 +41308,11 @@ function peg$parse(input, options) {
         s5 = peg$currPos;
         s6 = peg$parse_();
         s7 = input.substr(peg$currPos, 10);
-        if (s7.toLowerCase() === peg$c153) {
+        if (s7.toLowerCase() === peg$c197) {
           peg$currPos += (10);
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e159); }
+          if (peg$silentFails === 0) { peg$fail(peg$e206); }
         }
         if (s7 !== peg$FAILED) {
           s8 = peg$currPos;
@@ -31934,11 +41355,11 @@ function peg$parse(input, options) {
         s6 = peg$currPos;
         s7 = peg$parse_();
         s8 = input.substr(peg$currPos, 9);
-        if (s8.toLowerCase() === peg$c154) {
+        if (s8.toLowerCase() === peg$c198) {
           peg$currPos += (9);
         } else {
           s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e160); }
+          if (peg$silentFails === 0) { peg$fail(peg$e207); }
         }
         if (s8 !== peg$FAILED) {
           s9 = peg$currPos;
@@ -31974,11 +41395,11 @@ function peg$parse(input, options) {
         s7 = peg$currPos;
         s8 = peg$parse_();
         s9 = input.substr(peg$currPos, 12);
-        if (s9.toLowerCase() === peg$c155) {
+        if (s9.toLowerCase() === peg$c199) {
           peg$currPos += (12);
         } else {
           s9 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e161); }
+          if (peg$silentFails === 0) { peg$fail(peg$e208); }
         }
         if (s9 !== peg$FAILED) {
           s10 = peg$currPos;
@@ -32014,11 +41435,11 @@ function peg$parse(input, options) {
         s8 = peg$currPos;
         s9 = peg$parse_();
         s10 = input.substr(peg$currPos, 12);
-        if (s10.toLowerCase() === peg$c156) {
+        if (s10.toLowerCase() === peg$c200) {
           peg$currPos += (12);
         } else {
           s10 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e162); }
+          if (peg$silentFails === 0) { peg$fail(peg$e209); }
         }
         if (s10 !== peg$FAILED) {
           s11 = peg$currPos;
@@ -32054,11 +41475,11 @@ function peg$parse(input, options) {
         s9 = peg$currPos;
         s10 = peg$parse_();
         s11 = input.substr(peg$currPos, 13);
-        if (s11.toLowerCase() === peg$c157) {
+        if (s11.toLowerCase() === peg$c201) {
           peg$currPos += (13);
         } else {
           s11 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e163); }
+          if (peg$silentFails === 0) { peg$fail(peg$e210); }
         }
         if (s11 !== peg$FAILED) {
           s12 = peg$currPos;
@@ -32092,7 +41513,7 @@ function peg$parse(input, options) {
           s9 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f206(s1, s3, s4, s5, s6, s7, s8, s9);
+        s0 = peg$f313(s1, s3, s4, s5, s6, s7, s8, s9);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -32110,7 +41531,7 @@ function peg$parse(input, options) {
   function peg$parseDictDefinition() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 129;
+    const key = peg$currPos * 508 + 171;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -32150,7 +41571,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f207(s1);
+      s1 = peg$f314(s1);
     }
     s0 = s1;
 
@@ -32162,7 +41583,7 @@ function peg$parse(input, options) {
   function peg$parseDictClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14;
 
-    const key = peg$currPos * 466 + 130;
+    const key = peg$currPos * 508 + 172;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -32173,11 +41594,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c48) {
+    if (s1.toLowerCase() === peg$c52) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e53); }
+      if (peg$silentFails === 0) { peg$fail(peg$e57); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -32199,11 +41620,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 3);
-        if (s4.toLowerCase() === peg$c49) {
+        if (s4.toLowerCase() === peg$c53) {
           peg$currPos += (3);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e54); }
+          if (peg$silentFails === 0) { peg$fail(peg$e58); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -32230,11 +41651,11 @@ function peg$parse(input, options) {
               s9 = peg$currPos;
               s10 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s11 = peg$c15;
+                s11 = peg$c24;
                 peg$currPos++;
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s11 !== peg$FAILED) {
                 s12 = peg$parse_();
@@ -32255,11 +41676,11 @@ function peg$parse(input, options) {
                 s9 = peg$currPos;
                 s10 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s11 = peg$c15;
+                  s11 = peg$c24;
                   peg$currPos++;
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$parse_();
@@ -32277,7 +41698,7 @@ function peg$parse(input, options) {
                 }
               }
               peg$savedPos = s0;
-              s0 = peg$f208(s7, s8);
+              s0 = peg$f315(s7, s8);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -32301,11 +41722,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c158) {
+      if (s1.toLowerCase() === peg$c202) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e164); }
+        if (peg$silentFails === 0) { peg$fail(peg$e211); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -32327,11 +41748,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 40) {
-            s4 = peg$c21;
+            s4 = peg$c25;
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$parse_();
@@ -32339,11 +41760,11 @@ function peg$parse(input, options) {
             if (s6 !== peg$FAILED) {
               s7 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 40) {
-                s8 = peg$c21;
+                s8 = peg$c25;
                 peg$currPos++;
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                if (peg$silentFails === 0) { peg$fail(peg$e29); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$parse_();
@@ -32353,24 +41774,24 @@ function peg$parse(input, options) {
                 }
                 s11 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 41) {
-                  s12 = peg$c22;
+                  s12 = peg$c26;
                   peg$currPos++;
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 41) {
-                    s14 = peg$c22;
+                    s14 = peg$c26;
                     peg$currPos++;
                   } else {
                     s14 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
                   }
                   if (s14 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f209(s6, s10);
+                    s0 = peg$f316(s6, s10);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -32402,11 +41823,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 8);
-        if (s1.toLowerCase() === peg$c159) {
+        if (s1.toLowerCase() === peg$c203) {
           peg$currPos += (8);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e165); }
+          if (peg$silentFails === 0) { peg$fail(peg$e212); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -32428,11 +41849,11 @@ function peg$parse(input, options) {
           if (s2 !== peg$FAILED) {
             s3 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s4 = peg$c21;
+              s4 = peg$c25;
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s4 !== peg$FAILED) {
               s5 = peg$parse_();
@@ -32440,15 +41861,15 @@ function peg$parse(input, options) {
               if (s6 !== peg$FAILED) {
                 s7 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 41) {
-                  s8 = peg$c22;
+                  s8 = peg$c26;
                   peg$currPos++;
                 } else {
                   s8 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
                 if (s8 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f210(s6);
+                  s0 = peg$f317(s6);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -32472,11 +41893,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 8);
-          if (s1.toLowerCase() === peg$c159) {
+          if (s1.toLowerCase() === peg$c203) {
             peg$currPos += (8);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e165); }
+            if (peg$silentFails === 0) { peg$fail(peg$e212); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -32498,11 +41919,11 @@ function peg$parse(input, options) {
             if (s2 !== peg$FAILED) {
               s3 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 40) {
-                s4 = peg$c21;
+                s4 = peg$c25;
                 peg$currPos++;
               } else {
                 s4 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                if (peg$silentFails === 0) { peg$fail(peg$e29); }
               }
               if (s4 !== peg$FAILED) {
                 s5 = peg$parse_();
@@ -32537,15 +41958,15 @@ function peg$parse(input, options) {
                 if (s6 !== peg$FAILED) {
                   s7 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 41) {
-                    s8 = peg$c22;
+                    s8 = peg$c26;
                     peg$currPos++;
                   } else {
                     s8 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
                   }
                   if (s8 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f211(s6);
+                    s0 = peg$f318(s6);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -32569,11 +41990,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 6);
-            if (s1.toLowerCase() === peg$c160) {
+            if (s1.toLowerCase() === peg$c204) {
               peg$currPos += (6);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e166); }
+              if (peg$silentFails === 0) { peg$fail(peg$e213); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -32595,11 +42016,11 @@ function peg$parse(input, options) {
               if (s2 !== peg$FAILED) {
                 s3 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 40) {
-                  s4 = peg$c21;
+                  s4 = peg$c25;
                   peg$currPos++;
                 } else {
                   s4 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e29); }
                 }
                 if (s4 !== peg$FAILED) {
                   s5 = peg$parse_();
@@ -32608,11 +42029,11 @@ function peg$parse(input, options) {
                     s7 = peg$currPos;
                     s8 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 40) {
-                      s9 = peg$c21;
+                      s9 = peg$c25;
                       peg$currPos++;
                     } else {
                       s9 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e29); }
                     }
                     if (s9 !== peg$FAILED) {
                       s10 = peg$parse_();
@@ -32622,11 +42043,11 @@ function peg$parse(input, options) {
                       }
                       s12 = peg$parse_();
                       if (input.charCodeAt(peg$currPos) === 41) {
-                        s13 = peg$c22;
+                        s13 = peg$c26;
                         peg$currPos++;
                       } else {
                         s13 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e30); }
                       }
                       if (s13 !== peg$FAILED) {
                         s8 = [s8, s9, s10, s11, s12, s13];
@@ -32644,15 +42065,15 @@ function peg$parse(input, options) {
                     }
                     s8 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 41) {
-                      s9 = peg$c22;
+                      s9 = peg$c26;
                       peg$currPos++;
                     } else {
                       s9 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e30); }
                     }
                     if (s9 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f212(s6, s7);
+                      s0 = peg$f319(s6, s7);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -32676,11 +42097,11 @@ function peg$parse(input, options) {
             if (s0 === peg$FAILED) {
               s0 = peg$currPos;
               s1 = input.substr(peg$currPos, 5);
-              if (s1.toLowerCase() === peg$c161) {
+              if (s1.toLowerCase() === peg$c205) {
                 peg$currPos += (5);
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e167); }
+                if (peg$silentFails === 0) { peg$fail(peg$e214); }
               }
               if (s1 !== peg$FAILED) {
                 s2 = peg$currPos;
@@ -32702,11 +42123,11 @@ function peg$parse(input, options) {
                 if (s2 !== peg$FAILED) {
                   s3 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 40) {
-                    s4 = peg$c21;
+                    s4 = peg$c25;
                     peg$currPos++;
                   } else {
                     s4 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e29); }
                   }
                   if (s4 !== peg$FAILED) {
                     s5 = peg$parse_();
@@ -32714,15 +42135,15 @@ function peg$parse(input, options) {
                     if (s6 !== peg$FAILED) {
                       s7 = peg$parse_();
                       if (input.charCodeAt(peg$currPos) === 41) {
-                        s8 = peg$c22;
+                        s8 = peg$c26;
                         peg$currPos++;
                       } else {
                         s8 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e30); }
                       }
                       if (s8 !== peg$FAILED) {
                         peg$savedPos = s0;
-                        s0 = peg$f213(s6);
+                        s0 = peg$f320(s6);
                       } else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
@@ -32751,7 +42172,7 @@ function peg$parse(input, options) {
                   s3 = peg$parseSettingsList();
                   if (s3 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f214(s3);
+                    s0 = peg$f321(s3);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -32763,11 +42184,11 @@ function peg$parse(input, options) {
                 if (s0 === peg$FAILED) {
                   s0 = peg$currPos;
                   s1 = input.substr(peg$currPos, 8);
-                  if (s1.toLowerCase() === peg$c43) {
+                  if (s1.toLowerCase() === peg$c47) {
                     peg$currPos += (8);
                   } else {
                     s1 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e51); }
                   }
                   if (s1 !== peg$FAILED) {
                     s2 = peg$currPos;
@@ -32789,11 +42210,11 @@ function peg$parse(input, options) {
                     if (s2 !== peg$FAILED) {
                       s3 = peg$parse_();
                       if (input.charCodeAt(peg$currPos) === 40) {
-                        s4 = peg$c21;
+                        s4 = peg$c25;
                         peg$currPos++;
                       } else {
                         s4 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e29); }
                       }
                       if (s4 !== peg$FAILED) {
                         s5 = peg$parse_();
@@ -32803,15 +42224,15 @@ function peg$parse(input, options) {
                         }
                         s7 = peg$parse_();
                         if (input.charCodeAt(peg$currPos) === 41) {
-                          s8 = peg$c22;
+                          s8 = peg$c26;
                           peg$currPos++;
                         } else {
                           s8 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e30); }
                         }
                         if (s8 !== peg$FAILED) {
                           peg$savedPos = s0;
-                          s0 = peg$f215(s6);
+                          s0 = peg$f322(s6);
                         } else {
                           peg$currPos = s0;
                           s0 = peg$FAILED;
@@ -32831,11 +42252,11 @@ function peg$parse(input, options) {
                   if (s0 === peg$FAILED) {
                     s0 = peg$currPos;
                     s1 = input.substr(peg$currPos, 7);
-                    if (s1.toLowerCase() === peg$c39) {
+                    if (s1.toLowerCase() === peg$c43) {
                       peg$currPos += (7);
                     } else {
                       s1 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e43); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e47); }
                     }
                     if (s1 !== peg$FAILED) {
                       s2 = peg$currPos;
@@ -32859,7 +42280,7 @@ function peg$parse(input, options) {
                         s4 = peg$parseStringLiteral();
                         if (s4 !== peg$FAILED) {
                           peg$savedPos = s0;
-                          s0 = peg$f216(s4);
+                          s0 = peg$f323(s4);
                         } else {
                           peg$currPos = s0;
                           s0 = peg$FAILED;
@@ -32889,7 +42310,7 @@ function peg$parse(input, options) {
   function peg$parseDictLifetimeItems() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 131;
+    const key = peg$currPos * 508 + 173;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -32926,7 +42347,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f217(s1, s2);
+      s0 = peg$f324(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -32940,7 +42361,7 @@ function peg$parse(input, options) {
   function peg$parseDictLifetimeItem() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 132;
+    const key = peg$currPos * 508 + 174;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -32951,11 +42372,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c162) {
+    if (s1.toLowerCase() === peg$c206) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e168); }
+      if (peg$silentFails === 0) { peg$fail(peg$e215); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -33006,7 +42427,7 @@ function peg$parse(input, options) {
         }
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f218(s4);
+          s0 = peg$f325(s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -33022,11 +42443,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 3);
-      if (s1.toLowerCase() === peg$c163) {
+      if (s1.toLowerCase() === peg$c207) {
         peg$currPos += (3);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e169); }
+        if (peg$silentFails === 0) { peg$fail(peg$e216); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -33077,7 +42498,7 @@ function peg$parse(input, options) {
           }
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f219(s4);
+            s0 = peg$f326(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -33100,7 +42521,7 @@ function peg$parse(input, options) {
   function peg$parseDictKeyValueList() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 133;
+    const key = peg$currPos * 508 + 175;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -33137,7 +42558,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f220(s1, s2);
+      s0 = peg$f327(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -33151,7 +42572,7 @@ function peg$parse(input, options) {
   function peg$parseDictKeyValuePair() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 134;
+    const key = peg$currPos * 508 + 176;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -33167,7 +42588,7 @@ function peg$parse(input, options) {
       s3 = peg$parseExpression();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f221(s1, s3);
+        s0 = peg$f328(s1, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -33182,11 +42603,11 @@ function peg$parse(input, options) {
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s3 = peg$c21;
+          s3 = peg$c25;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
@@ -33194,15 +42615,15 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s7 = peg$c22;
+              s7 = peg$c26;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f222(s1, s5);
+              s0 = peg$f329(s1, s5);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -33227,7 +42648,7 @@ function peg$parse(input, options) {
           s3 = peg$parseClickHouseTypeArgs();
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f223(s1, s3);
+            s0 = peg$f330(s1, s3);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -33247,7 +42668,7 @@ function peg$parse(input, options) {
   function peg$parseDictStructurePairList() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 135;
+    const key = peg$currPos * 508 + 177;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -33284,7 +42705,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f224(s1, s2);
+      s0 = peg$f331(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -33298,7 +42719,7 @@ function peg$parse(input, options) {
   function peg$parseDictStructurePair() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 136;
+    const key = peg$currPos * 508 + 178;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -33314,7 +42735,7 @@ function peg$parse(input, options) {
       s3 = peg$parseColumnDataType();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f225(s1, s3);
+        s0 = peg$f332(s1, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -33332,7 +42753,7 @@ function peg$parse(input, options) {
   function peg$parseIndexColumnExpr() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 137;
+    const key = peg$currPos * 508 + 179;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -33347,19 +42768,19 @@ function peg$parse(input, options) {
       s2 = peg$currPos;
       s3 = peg$parse_();
       s4 = input.substr(peg$currPos, 3);
-      if (s4.toLowerCase() === peg$c164) {
+      if (s4.toLowerCase() === peg$c208) {
         peg$currPos += (3);
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e170); }
+        if (peg$silentFails === 0) { peg$fail(peg$e217); }
       }
       if (s4 === peg$FAILED) {
         s4 = input.substr(peg$currPos, 4);
-        if (s4.toLowerCase() === peg$c130) {
+        if (s4.toLowerCase() === peg$c184) {
           peg$currPos += (4);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e136); }
+          if (peg$silentFails === 0) { peg$fail(peg$e193); }
         }
       }
       if (s4 !== peg$FAILED) {
@@ -33394,7 +42815,7 @@ function peg$parse(input, options) {
         s2 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f226(s1, s2);
+      s0 = peg$f333(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -33408,7 +42829,7 @@ function peg$parse(input, options) {
   function peg$parseCreateWorkloadStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
 
-    const key = peg$currPos * 466 + 138;
+    const key = peg$currPos * 508 + 180;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -33419,11 +42840,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -33446,11 +42867,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -33472,11 +42893,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -33519,11 +42940,11 @@ function peg$parse(input, options) {
         }
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 8);
-        if (s5.toLowerCase() === peg$c140) {
+        if (s5.toLowerCase() === peg$c185) {
           peg$currPos += (8);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e146); }
+          if (peg$silentFails === 0) { peg$fail(peg$e194); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -33546,11 +42967,11 @@ function peg$parse(input, options) {
             s7 = peg$currPos;
             s8 = peg$parse_();
             s9 = input.substr(peg$currPos, 2);
-            if (s9.toLowerCase() === peg$c25) {
+            if (s9.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s9 !== peg$FAILED) {
               s10 = peg$currPos;
@@ -33572,11 +42993,11 @@ function peg$parse(input, options) {
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 3);
-                if (s12.toLowerCase() === peg$c26) {
+                if (s12.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -33598,11 +43019,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 6);
-                    if (s15.toLowerCase() === peg$c27) {
+                    if (s15.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -33657,11 +43078,11 @@ function peg$parse(input, options) {
               s10 = peg$currPos;
               s11 = peg$parse_();
               s12 = input.substr(peg$currPos, 2);
-              if (s12.toLowerCase() === peg$c89) {
+              if (s12.toLowerCase() === peg$c93) {
                 peg$currPos += (2);
               } else {
                 s12 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e94); }
+                if (peg$silentFails === 0) { peg$fail(peg$e98); }
               }
               if (s12 !== peg$FAILED) {
                 s13 = peg$currPos;
@@ -33715,7 +43136,7 @@ function peg$parse(input, options) {
                 s11 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f227(s3, s7, s9, s10, s11);
+              s0 = peg$f334(s3, s7, s9, s10, s11);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -33745,7 +43166,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
 
-    const key = peg$currPos * 466 + 139;
+    const key = peg$currPos * 508 + 181;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -33756,11 +43177,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -33783,11 +43204,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -33809,11 +43230,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -33856,11 +43277,11 @@ function peg$parse(input, options) {
         }
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 4);
-        if (s5.toLowerCase() === peg$c133) {
+        if (s5.toLowerCase() === peg$c126) {
           peg$currPos += (4);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e139); }
+          if (peg$silentFails === 0) { peg$fail(peg$e135); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -33883,11 +43304,11 @@ function peg$parse(input, options) {
             s7 = peg$currPos;
             s8 = peg$parse_();
             s9 = input.substr(peg$currPos, 2);
-            if (s9.toLowerCase() === peg$c25) {
+            if (s9.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s9 !== peg$FAILED) {
               s10 = peg$currPos;
@@ -33909,11 +43330,11 @@ function peg$parse(input, options) {
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 3);
-                if (s12.toLowerCase() === peg$c26) {
+                if (s12.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -33935,11 +43356,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 6);
-                    if (s15.toLowerCase() === peg$c27) {
+                    if (s15.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -33991,11 +43412,11 @@ function peg$parse(input, options) {
             s8 = peg$currPos;
             s9 = peg$parse_();
             s10 = input.substr(peg$currPos, 2);
-            if (s10.toLowerCase() === peg$c149) {
+            if (s10.toLowerCase() === peg$c193) {
               peg$currPos += (2);
             } else {
               s10 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e155); }
+              if (peg$silentFails === 0) { peg$fail(peg$e202); }
             }
             if (s10 !== peg$FAILED) {
               s11 = peg$currPos;
@@ -34017,11 +43438,11 @@ function peg$parse(input, options) {
               if (s11 !== peg$FAILED) {
                 s12 = peg$parse_();
                 s13 = input.substr(peg$currPos, 7);
-                if (s13.toLowerCase() === peg$c70) {
+                if (s13.toLowerCase() === peg$c74) {
                   peg$currPos += (7);
                 } else {
                   s13 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e75); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e79); }
                 }
                 if (s13 !== peg$FAILED) {
                   s14 = peg$currPos;
@@ -34090,7 +43511,7 @@ function peg$parse(input, options) {
                 }
               }
               peg$savedPos = s0;
-              s0 = peg$f228(s3, s7, s8, s10, s11);
+              s0 = peg$f335(s3, s7, s8, s10, s11);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -34120,7 +43541,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserClause() {
     let s0;
 
-    const key = peg$currPos * 466 + 140;
+    const key = peg$currPos * 508 + 182;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -34160,7 +43581,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserIdentifiedClause() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 141;
+    const key = peg$currPos * 508 + 183;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -34171,11 +43592,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c26) {
+    if (s1.toLowerCase() === peg$c30) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e30); }
+      if (peg$silentFails === 0) { peg$fail(peg$e34); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -34197,11 +43618,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 10);
-        if (s4.toLowerCase() === peg$c165) {
+        if (s4.toLowerCase() === peg$c127) {
           peg$currPos += (10);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e171); }
+          if (peg$silentFails === 0) { peg$fail(peg$e136); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -34222,7 +43643,7 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f229();
+            s0 = peg$f336();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -34242,11 +43663,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 10);
-      if (s1.toLowerCase() === peg$c165) {
+      if (s1.toLowerCase() === peg$c127) {
         peg$currPos += (10);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e171); }
+        if (peg$silentFails === 0) { peg$fail(peg$e136); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -34270,7 +43691,7 @@ function peg$parse(input, options) {
           s4 = peg$parseCreateUserAuthMethods();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f230(s4);
+            s0 = peg$f337(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -34293,7 +43714,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserHostClause() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 142;
+    const key = peg$currPos * 508 + 184;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -34304,11 +43725,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c166) {
+    if (s1.toLowerCase() === peg$c128) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e172); }
+      if (peg$silentFails === 0) { peg$fail(peg$e137); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -34332,7 +43753,7 @@ function peg$parse(input, options) {
         s4 = peg$parseHostItemList();
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f231(s4);
+          s0 = peg$f338(s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -34354,7 +43775,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserSettingsClause() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 143;
+    const key = peg$currPos * 508 + 185;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -34365,11 +43786,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c43) {
+    if (s1.toLowerCase() === peg$c47) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e47); }
+      if (peg$silentFails === 0) { peg$fail(peg$e51); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -34416,7 +43837,7 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f232();
+            s0 = peg$f339();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -34436,11 +43857,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 8);
-      if (s1.toLowerCase() === peg$c43) {
+      if (s1.toLowerCase() === peg$c47) {
         peg$currPos += (8);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e47); }
+        if (peg$silentFails === 0) { peg$fail(peg$e51); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -34464,7 +43885,7 @@ function peg$parse(input, options) {
           s4 = peg$parseAccessControlSettingsList();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f233(s4);
+            s0 = peg$f340(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -34487,7 +43908,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserDefaultRoleClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 144;
+    const key = peg$currPos * 508 + 186;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -34552,7 +43973,7 @@ function peg$parse(input, options) {
             s7 = peg$parseSetRoleList();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f234(s7);
+              s0 = peg$f341(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -34582,7 +44003,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserDefaultDatabaseClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 145;
+    const key = peg$currPos * 508 + 187;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -34619,11 +44040,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 8);
-        if (s4.toLowerCase() === peg$c114) {
+        if (s4.toLowerCase() === peg$c112) {
           peg$currPos += (8);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e120); }
+          if (peg$silentFails === 0) { peg$fail(peg$e118); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -34647,7 +44068,7 @@ function peg$parse(input, options) {
             s7 = peg$parseAliasName();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f235(s7);
+              s0 = peg$f342(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -34677,7 +44098,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserGranteesClause() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 146;
+    const key = peg$currPos * 508 + 188;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -34688,11 +44109,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c167) {
+    if (s1.toLowerCase() === peg$c129) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e173); }
+      if (peg$silentFails === 0) { peg$fail(peg$e138); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -34716,7 +44137,7 @@ function peg$parse(input, options) {
         s4 = peg$parseSetRoleList();
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f236(s4);
+          s0 = peg$f343(s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -34738,7 +44159,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserValidUntilClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 147;
+    const key = peg$currPos * 508 + 189;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -34749,11 +44170,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c168) {
+    if (s1.toLowerCase() === peg$c130) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e174); }
+      if (peg$silentFails === 0) { peg$fail(peg$e139); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -34775,11 +44196,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c169) {
+        if (s4.toLowerCase() === peg$c131) {
           peg$currPos += (5);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e175); }
+          if (peg$silentFails === 0) { peg$fail(peg$e140); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -34803,7 +44224,7 @@ function peg$parse(input, options) {
             s7 = peg$parseStringLiteral();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f237(s7);
+              s0 = peg$f344(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -34833,7 +44254,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserOnClusterClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 148;
+    const key = peg$currPos * 508 + 190;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -34844,11 +44265,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c103) {
+    if (s1.toLowerCase() === peg$c94) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e108); }
+      if (peg$silentFails === 0) { peg$fail(peg$e99); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -34870,11 +44291,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 7);
-        if (s4.toLowerCase() === peg$c170) {
+        if (s4.toLowerCase() === peg$c139) {
           peg$currPos += (7);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e176); }
+          if (peg$silentFails === 0) { peg$fail(peg$e148); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -34899,7 +44320,7 @@ function peg$parse(input, options) {
             s8 = peg$parseStringLiteral();
             if (s8 !== peg$FAILED) {
               peg$savedPos = s7;
-              s8 = peg$f238();
+              s8 = peg$f345();
             }
             s7 = s8;
             if (s7 === peg$FAILED) {
@@ -34907,7 +44328,7 @@ function peg$parse(input, options) {
             }
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f239(s7);
+              s0 = peg$f346(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -34937,7 +44358,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserNameList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 149;
+    const key = peg$currPos * 508 + 191;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -34953,11 +44374,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -34978,11 +44399,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -35000,7 +44421,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f240(s1, s2);
+      s0 = peg$f347(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -35014,7 +44435,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserNameItem() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 150;
+    const key = peg$currPos * 508 + 192;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -35028,52 +44449,52 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 64) {
-        s3 = peg$c171;
+        s3 = peg$c209;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e177); }
+        if (peg$silentFails === 0) { peg$fail(peg$e218); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 39) {
-          s5 = peg$c108;
+          s5 = peg$c99;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e113); }
+          if (peg$silentFails === 0) { peg$fail(peg$e104); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
           s7 = [];
           s8 = input.charAt(peg$currPos);
-          if (peg$r5.test(s8)) {
+          if (peg$r8.test(s8)) {
             peg$currPos++;
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e178); }
+            if (peg$silentFails === 0) { peg$fail(peg$e219); }
           }
           while (s8 !== peg$FAILED) {
             s7.push(s8);
             s8 = input.charAt(peg$currPos);
-            if (peg$r5.test(s8)) {
+            if (peg$r8.test(s8)) {
               peg$currPos++;
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e178); }
+              if (peg$silentFails === 0) { peg$fail(peg$e219); }
             }
           }
           s6 = input.substring(s6, peg$currPos);
           if (input.charCodeAt(peg$currPos) === 39) {
-            s7 = peg$c108;
+            s7 = peg$c99;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e113); }
+            if (peg$silentFails === 0) { peg$fail(peg$e104); }
           }
           if (s7 !== peg$FAILED) {
             peg$savedPos = s4;
-            s4 = peg$f241(s1, s6);
+            s4 = peg$f348(s1, s6);
           } else {
             peg$currPos = s4;
             s4 = peg$FAILED;
@@ -35086,21 +44507,21 @@ function peg$parse(input, options) {
           s4 = peg$currPos;
           s5 = [];
           s6 = input.charAt(peg$currPos);
-          if (peg$r6.test(s6)) {
+          if (peg$r9.test(s6)) {
             peg$currPos++;
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e179); }
+            if (peg$silentFails === 0) { peg$fail(peg$e220); }
           }
           if (s6 !== peg$FAILED) {
             while (s6 !== peg$FAILED) {
               s5.push(s6);
               s6 = input.charAt(peg$currPos);
-              if (peg$r6.test(s6)) {
+              if (peg$r9.test(s6)) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e179); }
+                if (peg$silentFails === 0) { peg$fail(peg$e220); }
               }
             }
           } else {
@@ -35114,7 +44535,7 @@ function peg$parse(input, options) {
         }
         if (s4 !== peg$FAILED) {
           peg$savedPos = s2;
-          s2 = peg$f242(s1, s4);
+          s2 = peg$f349(s1, s4);
         } else {
           peg$currPos = s2;
           s2 = peg$FAILED;
@@ -35127,7 +44548,7 @@ function peg$parse(input, options) {
         s2 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f243(s1, s2);
+      s0 = peg$f350(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -35141,7 +44562,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserNameValue() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 151;
+    const key = peg$currPos * 508 + 193;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -35152,43 +44573,43 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 123) {
-      s1 = peg$c172;
+      s1 = peg$c210;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e180); }
+      if (peg$silentFails === 0) { peg$fail(peg$e221); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
       s3 = [];
       s4 = input.charAt(peg$currPos);
-      if (peg$r7.test(s4)) {
+      if (peg$r10.test(s4)) {
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e181); }
+        if (peg$silentFails === 0) { peg$fail(peg$e222); }
       }
       while (s4 !== peg$FAILED) {
         s3.push(s4);
         s4 = input.charAt(peg$currPos);
-        if (peg$r7.test(s4)) {
+        if (peg$r10.test(s4)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e181); }
+          if (peg$silentFails === 0) { peg$fail(peg$e222); }
         }
       }
       s2 = input.substring(s2, peg$currPos);
       if (input.charCodeAt(peg$currPos) === 125) {
-        s3 = peg$c173;
+        s3 = peg$c211;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e182); }
+        if (peg$silentFails === 0) { peg$fail(peg$e223); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f244(s2);
+        s0 = peg$f351(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -35200,11 +44621,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 39) {
-        s1 = peg$c108;
+        s1 = peg$c99;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e113); }
+        if (peg$silentFails === 0) { peg$fail(peg$e104); }
       }
       if (s1 !== peg$FAILED) {
         s2 = [];
@@ -35214,15 +44635,15 @@ function peg$parse(input, options) {
           s3 = peg$parseSingleQuotedUserChar();
         }
         if (input.charCodeAt(peg$currPos) === 39) {
-          s3 = peg$c108;
+          s3 = peg$c99;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e113); }
+          if (peg$silentFails === 0) { peg$fail(peg$e104); }
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f245(s2);
+          s0 = peg$f352(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -35244,7 +44665,7 @@ function peg$parse(input, options) {
   function peg$parseSingleQuotedUserChar() {
     let s0, s1, s2;
 
-    const key = peg$currPos * 466 + 152;
+    const key = peg$currPos * 508 + 194;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -35254,44 +44675,44 @@ function peg$parse(input, options) {
     }
 
     s0 = peg$currPos;
-    if (input.substr(peg$currPos, 2) === peg$c109) {
-      s1 = peg$c109;
+    if (input.substr(peg$currPos, 2) === peg$c100) {
+      s1 = peg$c100;
       peg$currPos += 2;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e114); }
+      if (peg$silentFails === 0) { peg$fail(peg$e105); }
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f246();
+      s1 = peg$f353();
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
-      if (input.substr(peg$currPos, 2) === peg$c110) {
-        s1 = peg$c110;
+      if (input.substr(peg$currPos, 2) === peg$c101) {
+        s1 = peg$c101;
         peg$currPos += 2;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e115); }
+        if (peg$silentFails === 0) { peg$fail(peg$e106); }
       }
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f247();
+        s1 = peg$f354();
       }
       s0 = s1;
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
-        if (input.substr(peg$currPos, 2) === peg$c111) {
-          s1 = peg$c111;
+        if (input.substr(peg$currPos, 2) === peg$c102) {
+          s1 = peg$c102;
           peg$currPos += 2;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e116); }
+          if (peg$silentFails === 0) { peg$fail(peg$e107); }
         }
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f248();
+          s1 = peg$f355();
         }
         s0 = s1;
         if (s0 === peg$FAILED) {
@@ -35299,11 +44720,11 @@ function peg$parse(input, options) {
           s1 = peg$currPos;
           peg$silentFails++;
           if (input.charCodeAt(peg$currPos) === 39) {
-            s2 = peg$c108;
+            s2 = peg$c99;
             peg$currPos++;
           } else {
             s2 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e113); }
+            if (peg$silentFails === 0) { peg$fail(peg$e104); }
           }
           peg$silentFails--;
           if (s2 === peg$FAILED) {
@@ -35318,11 +44739,11 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s2 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e21); }
+              if (peg$silentFails === 0) { peg$fail(peg$e24); }
             }
             if (s2 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f249(s2);
+              s0 = peg$f356(s2);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -35343,7 +44764,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserAuthMethods() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 153;
+    const key = peg$currPos * 508 + 195;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -35354,11 +44775,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c53) {
+    if (s1.toLowerCase() === peg$c57) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e58); }
+      if (peg$silentFails === 0) { peg$fail(peg$e62); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -35380,11 +44801,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 7);
-        if (s4.toLowerCase() === peg$c174) {
+        if (s4.toLowerCase() === peg$c212) {
           peg$currPos += (7);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e183); }
+          if (peg$silentFails === 0) { peg$fail(peg$e224); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -35406,11 +44827,11 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = input.substr(peg$currPos, 2);
-            if (s7.toLowerCase() === peg$c80) {
+            if (s7.toLowerCase() === peg$c84) {
               peg$currPos += (2);
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e85); }
+              if (peg$silentFails === 0) { peg$fail(peg$e89); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$currPos;
@@ -35434,7 +44855,7 @@ function peg$parse(input, options) {
                 s10 = peg$parseCreateUserSSHKeyList();
                 if (s10 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f250(s10);
+                  s0 = peg$f357(s10);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -35471,11 +44892,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -35496,11 +44917,11 @@ function peg$parse(input, options) {
           s3 = peg$currPos;
           s4 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s5 = peg$c15;
+            s5 = peg$c24;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
@@ -35518,7 +44939,7 @@ function peg$parse(input, options) {
           }
         }
         peg$savedPos = s0;
-        s0 = peg$f251(s1, s2);
+        s0 = peg$f358(s1, s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -35533,7 +44954,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserAuthMethod() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 154;
+    const key = peg$currPos * 508 + 196;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -35544,11 +44965,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c53) {
+    if (s1.toLowerCase() === peg$c57) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e58); }
+      if (peg$silentFails === 0) { peg$fail(peg$e62); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -35570,11 +44991,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.charAt(peg$currPos);
-        if (peg$r8.test(s4)) {
+        if (peg$r5.test(s4)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e184); }
+          if (peg$silentFails === 0) { peg$fail(peg$e129); }
         }
         if (s4 !== peg$FAILED) {
           s5 = [];
@@ -35599,7 +45020,7 @@ function peg$parse(input, options) {
           s7 = peg$parseCreateUserAuthSecret();
           if (s7 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f252(s7);
+            s0 = peg$f359(s7);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -35619,11 +45040,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c53) {
+      if (s1.toLowerCase() === peg$c57) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e58); }
+        if (peg$silentFails === 0) { peg$fail(peg$e62); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -35645,11 +45066,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.charAt(peg$currPos);
-          if (peg$r8.test(s4)) {
+          if (peg$r5.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e184); }
+            if (peg$silentFails === 0) { peg$fail(peg$e129); }
           }
           if (s4 !== peg$FAILED) {
             s5 = [];
@@ -35671,7 +45092,7 @@ function peg$parse(input, options) {
               }
             }
             peg$savedPos = s0;
-            s0 = peg$f253();
+            s0 = peg$f360();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -35687,11 +45108,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.charAt(peg$currPos);
-        if (peg$r8.test(s1)) {
+        if (peg$r5.test(s1)) {
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e184); }
+          if (peg$silentFails === 0) { peg$fail(peg$e129); }
         }
         if (s1 !== peg$FAILED) {
           s2 = [];
@@ -35716,7 +45137,7 @@ function peg$parse(input, options) {
           s4 = peg$parseCreateUserAuthSecret();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f254(s4);
+            s0 = peg$f361(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -35730,7 +45151,7 @@ function peg$parse(input, options) {
           s1 = peg$parseCreateUserAuthSecret();
           if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
-            s1 = peg$f255(s1);
+            s1 = peg$f362(s1);
           }
           s0 = s1;
         }
@@ -35745,7 +45166,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserAuthSecret() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 155;
+    const key = peg$currPos * 508 + 197;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -35756,11 +45177,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c80) {
+    if (s1.toLowerCase() === peg$c84) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e85); }
+      if (peg$silentFails === 0) { peg$fail(peg$e89); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -35784,7 +45205,7 @@ function peg$parse(input, options) {
         s4 = peg$parseCreateUserAuthSecretValue();
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f256(s4);
+          s0 = peg$f363(s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -35800,11 +45221,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c175) {
+      if (s1.toLowerCase() === peg$c213) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e185); }
+        if (peg$silentFails === 0) { peg$fail(peg$e225); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -35828,7 +45249,7 @@ function peg$parse(input, options) {
           s4 = peg$parseCreateUserAuthSecretValue();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f257(s4);
+            s0 = peg$f364(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -35844,11 +45265,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 6);
-        if (s1.toLowerCase() === peg$c176) {
+        if (s1.toLowerCase() === peg$c214) {
           peg$currPos += (6);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e186); }
+          if (peg$silentFails === 0) { peg$fail(peg$e226); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -35872,7 +45293,7 @@ function peg$parse(input, options) {
             s4 = peg$parseCreateUserAuthSecretValue();
             if (s4 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f258(s4);
+              s0 = peg$f365(s4);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -35896,7 +45317,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserAuthSecretValue() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 156;
+    const key = peg$currPos * 508 + 198;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -35909,49 +45330,49 @@ function peg$parse(input, options) {
     s1 = peg$parseStringLiteral();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f259(s1);
+      s1 = peg$f366(s1);
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 123) {
-        s1 = peg$c172;
+        s1 = peg$c210;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e180); }
+        if (peg$silentFails === 0) { peg$fail(peg$e221); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
         s3 = [];
         s4 = input.charAt(peg$currPos);
-        if (peg$r7.test(s4)) {
+        if (peg$r10.test(s4)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e181); }
+          if (peg$silentFails === 0) { peg$fail(peg$e222); }
         }
         while (s4 !== peg$FAILED) {
           s3.push(s4);
           s4 = input.charAt(peg$currPos);
-          if (peg$r7.test(s4)) {
+          if (peg$r10.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e181); }
+            if (peg$silentFails === 0) { peg$fail(peg$e222); }
           }
         }
         s2 = input.substring(s2, peg$currPos);
         if (input.charCodeAt(peg$currPos) === 125) {
-          s3 = peg$c173;
+          s3 = peg$c211;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e182); }
+          if (peg$silentFails === 0) { peg$fail(peg$e223); }
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f260(s2);
+          s0 = peg$f367(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -35970,7 +45391,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserSSHKeyList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 157;
+    const key = peg$currPos * 508 + 199;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -35986,11 +45407,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -36011,11 +45432,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -36033,7 +45454,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f261(s1, s2);
+      s0 = peg$f368(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -36047,7 +45468,7 @@ function peg$parse(input, options) {
   function peg$parseCreateUserSSHKey() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 158;
+    const key = peg$currPos * 508 + 200;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -36058,11 +45479,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c49) {
+    if (s1.toLowerCase() === peg$c53) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e54); }
+      if (peg$silentFails === 0) { peg$fail(peg$e58); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -36087,11 +45508,11 @@ function peg$parse(input, options) {
         if (s4 !== peg$FAILED) {
           s5 = peg$parse_();
           s6 = input.substr(peg$currPos, 4);
-          if (s6.toLowerCase() === peg$c33) {
+          if (s6.toLowerCase() === peg$c37) {
             peg$currPos += (4);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e37); }
+            if (peg$silentFails === 0) { peg$fail(peg$e41); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$currPos;
@@ -36114,8 +45535,8 @@ function peg$parse(input, options) {
               s8 = peg$parse_();
               s9 = peg$parseStringLiteral();
               if (s9 !== peg$FAILED) {
-                s1 = [s1, s2, s3, s4, s5, s6, s7, s8, s9];
-                s0 = s1;
+                peg$savedPos = s0;
+                s0 = peg$f369(s4, s9);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -36149,7 +45570,7 @@ function peg$parse(input, options) {
   function peg$parseHostItemList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 159;
+    const key = peg$currPos * 508 + 201;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -36165,11 +45586,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -36190,11 +45611,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -36212,7 +45633,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f262(s1, s2);
+      s0 = peg$f370(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -36226,7 +45647,7 @@ function peg$parse(input, options) {
   function peg$parseHostItems() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 160;
+    const key = peg$currPos * 508 + 202;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -36237,11 +45658,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c177) {
+    if (s1.toLowerCase() === peg$c215) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e187); }
+      if (peg$silentFails === 0) { peg$fail(peg$e227); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -36262,7 +45683,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f263();
+        s0 = peg$f371();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -36299,7 +45720,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f264();
+          s0 = peg$f372();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -36311,11 +45732,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 5);
-        if (s1.toLowerCase() === peg$c178) {
+        if (s1.toLowerCase() === peg$c216) {
           peg$currPos += (5);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e188); }
+          if (peg$silentFails === 0) { peg$fail(peg$e228); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -36336,7 +45757,7 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f265();
+            s0 = peg$f373();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -36348,11 +45769,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 4);
-          if (s1.toLowerCase() === peg$c78) {
+          if (s1.toLowerCase() === peg$c82) {
             peg$currPos += (4);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e83); }
+            if (peg$silentFails === 0) { peg$fail(peg$e87); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -36373,10 +45794,10 @@ function peg$parse(input, options) {
             }
             if (s2 !== peg$FAILED) {
               s3 = peg$parse_();
-              s4 = peg$parseStringLiteral();
+              s4 = peg$parseHostStringList();
               if (s4 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f266(s4);
+                s0 = peg$f374(s4);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -36392,11 +45813,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 6);
-            if (s1.toLowerCase() === peg$c179) {
+            if (s1.toLowerCase() === peg$c217) {
               peg$currPos += (6);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e189); }
+              if (peg$silentFails === 0) { peg$fail(peg$e229); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -36417,10 +45838,10 @@ function peg$parse(input, options) {
               }
               if (s2 !== peg$FAILED) {
                 s3 = peg$parse_();
-                s4 = peg$parseStringLiteral();
+                s4 = peg$parseHostStringList();
                 if (s4 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f267(s4);
+                  s0 = peg$f375(s4);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -36436,11 +45857,11 @@ function peg$parse(input, options) {
             if (s0 === peg$FAILED) {
               s0 = peg$currPos;
               s1 = input.substr(peg$currPos, 4);
-              if (s1.toLowerCase() === peg$c123) {
+              if (s1.toLowerCase() === peg$c172) {
                 peg$currPos += (4);
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e129); }
+                if (peg$silentFails === 0) { peg$fail(peg$e181); }
               }
               if (s1 !== peg$FAILED) {
                 s2 = peg$currPos;
@@ -36464,7 +45885,7 @@ function peg$parse(input, options) {
                   s4 = peg$parseHostStringList();
                   if (s4 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f268(s4);
+                    s0 = peg$f376(s4);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -36480,11 +45901,11 @@ function peg$parse(input, options) {
               if (s0 === peg$FAILED) {
                 s0 = peg$currPos;
                 s1 = input.substr(peg$currPos, 2);
-                if (s1.toLowerCase() === peg$c180) {
+                if (s1.toLowerCase() === peg$c218) {
                   peg$currPos += (2);
                 } else {
                   s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e190); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e230); }
                 }
                 if (s1 !== peg$FAILED) {
                   s2 = peg$currPos;
@@ -36508,7 +45929,7 @@ function peg$parse(input, options) {
                     s4 = peg$parseHostStringList();
                     if (s4 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f269(s4);
+                      s0 = peg$f377(s4);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -36536,7 +45957,7 @@ function peg$parse(input, options) {
   function peg$parseHostStringList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 161;
+    const key = peg$currPos * 508 + 203;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -36552,11 +45973,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -36577,11 +45998,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -36599,7 +46020,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f270(s1, s2);
+      s0 = peg$f378(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -36613,7 +46034,7 @@ function peg$parse(input, options) {
   function peg$parseAccessControlSettingsList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 162;
+    const key = peg$currPos * 508 + 204;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -36629,11 +46050,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -36654,11 +46075,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -36676,7 +46097,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f271(s1, s2);
+      s0 = peg$f379(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -36690,7 +46111,7 @@ function peg$parse(input, options) {
   function peg$parseAccessControlSettingsItem() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 163;
+    const key = peg$currPos * 508 + 205;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -36701,11 +46122,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c137) {
+    if (s1.toLowerCase() === peg$c140) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e143); }
+      if (peg$silentFails === 0) { peg$fail(peg$e149); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -36730,7 +46151,7 @@ function peg$parse(input, options) {
         s5 = peg$parseStringLiteral();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s4;
-          s5 = peg$f272();
+          s5 = peg$f380();
         }
         s4 = s5;
         if (s4 === peg$FAILED) {
@@ -36738,7 +46159,7 @@ function peg$parse(input, options) {
         }
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f273(s4);
+          s0 = peg$f381(s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -36754,11 +46175,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 7);
-      if (s1.toLowerCase() === peg$c181) {
+      if (s1.toLowerCase() === peg$c219) {
         peg$currPos += (7);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e191); }
+        if (peg$silentFails === 0) { peg$fail(peg$e231); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -36783,7 +46204,7 @@ function peg$parse(input, options) {
           s5 = peg$parseStringLiteral();
           if (s5 !== peg$FAILED) {
             peg$savedPos = s4;
-            s5 = peg$f274();
+            s5 = peg$f382();
           }
           s4 = s5;
           if (s4 === peg$FAILED) {
@@ -36791,7 +46212,7 @@ function peg$parse(input, options) {
           }
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f275(s4);
+            s0 = peg$f383(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -36811,11 +46232,11 @@ function peg$parse(input, options) {
           s2 = peg$currPos;
           s3 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 61) {
-            s4 = peg$c62;
+            s4 = peg$c66;
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e67); }
+            if (peg$silentFails === 0) { peg$fail(peg$e71); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$parse_();
@@ -36837,11 +46258,11 @@ function peg$parse(input, options) {
           s3 = peg$currPos;
           s4 = peg$parse_();
           s5 = input.substr(peg$currPos, 3);
-          if (s5.toLowerCase() === peg$c162) {
+          if (s5.toLowerCase() === peg$c206) {
             peg$currPos += (3);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e168); }
+            if (peg$silentFails === 0) { peg$fail(peg$e215); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$currPos;
@@ -36864,11 +46285,11 @@ function peg$parse(input, options) {
               s7 = peg$parse_();
               s8 = peg$currPos;
               if (input.charCodeAt(peg$currPos) === 61) {
-                s9 = peg$c62;
+                s9 = peg$c66;
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e67); }
+                if (peg$silentFails === 0) { peg$fail(peg$e71); }
               }
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
@@ -36903,11 +46324,11 @@ function peg$parse(input, options) {
           s4 = peg$currPos;
           s5 = peg$parse_();
           s6 = input.substr(peg$currPos, 3);
-          if (s6.toLowerCase() === peg$c163) {
+          if (s6.toLowerCase() === peg$c207) {
             peg$currPos += (3);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e169); }
+            if (peg$silentFails === 0) { peg$fail(peg$e216); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$currPos;
@@ -36930,11 +46351,11 @@ function peg$parse(input, options) {
               s8 = peg$parse_();
               s9 = peg$currPos;
               if (input.charCodeAt(peg$currPos) === 61) {
-                s10 = peg$c62;
+                s10 = peg$c66;
                 peg$currPos++;
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e67); }
+                if (peg$silentFails === 0) { peg$fail(peg$e71); }
               }
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
@@ -36969,27 +46390,27 @@ function peg$parse(input, options) {
           s5 = peg$currPos;
           s6 = peg$parse_();
           s7 = input.substr(peg$currPos, 5);
-          if (s7.toLowerCase() === peg$c182) {
+          if (s7.toLowerCase() === peg$c220) {
             peg$currPos += (5);
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e192); }
+            if (peg$silentFails === 0) { peg$fail(peg$e232); }
           }
           if (s7 === peg$FAILED) {
             s7 = input.substr(peg$currPos, 8);
-            if (s7.toLowerCase() === peg$c183) {
+            if (s7.toLowerCase() === peg$c221) {
               peg$currPos += (8);
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e193); }
+              if (peg$silentFails === 0) { peg$fail(peg$e233); }
             }
             if (s7 === peg$FAILED) {
               s7 = input.substr(peg$currPos, 8);
-              if (s7.toLowerCase() === peg$c184) {
+              if (s7.toLowerCase() === peg$c222) {
                 peg$currPos += (8);
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e194); }
+                if (peg$silentFails === 0) { peg$fail(peg$e234); }
               }
             }
           }
@@ -37025,7 +46446,7 @@ function peg$parse(input, options) {
             s5 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f276(s1, s2, s3, s4, s5);
+          s0 = peg$f384(s1, s2, s3, s4, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -37041,7 +46462,7 @@ function peg$parse(input, options) {
   function peg$parseAccessControlSettingName() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 164;
+    const key = peg$currPos * 508 + 206;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -37056,11 +46477,11 @@ function peg$parse(input, options) {
       s2 = [];
       s3 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 46) {
-        s4 = peg$c35;
+        s4 = peg$c39;
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s4 !== peg$FAILED) {
         s5 = peg$parseAliasName();
@@ -37079,11 +46500,11 @@ function peg$parse(input, options) {
         s2.push(s3);
         s3 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 46) {
-          s4 = peg$c35;
+          s4 = peg$c39;
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e39); }
+          if (peg$silentFails === 0) { peg$fail(peg$e43); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$parseAliasName();
@@ -37100,7 +46521,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f277(s1, s2);
+      s0 = peg$f385(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -37114,7 +46535,7 @@ function peg$parse(input, options) {
   function peg$parseCreateRoleStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
 
-    const key = peg$currPos * 466 + 165;
+    const key = peg$currPos * 508 + 207;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -37125,11 +46546,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -37152,11 +46573,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -37178,11 +46599,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -37252,11 +46673,11 @@ function peg$parse(input, options) {
             s7 = peg$currPos;
             s8 = peg$parse_();
             s9 = input.substr(peg$currPos, 2);
-            if (s9.toLowerCase() === peg$c25) {
+            if (s9.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s9 !== peg$FAILED) {
               s10 = peg$currPos;
@@ -37278,11 +46699,11 @@ function peg$parse(input, options) {
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 3);
-                if (s12.toLowerCase() === peg$c26) {
+                if (s12.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -37304,11 +46725,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 6);
-                    if (s15.toLowerCase() === peg$c27) {
+                    if (s15.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -37374,7 +46795,7 @@ function peg$parse(input, options) {
                 s10 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f278(s3, s7, s9, s10);
+              s0 = peg$f386(s3, s7, s9, s10);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -37404,7 +46825,7 @@ function peg$parse(input, options) {
   function peg$parseCreateRoleSettingsClause() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 166;
+    const key = peg$currPos * 508 + 208;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -37415,11 +46836,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c43) {
+    if (s1.toLowerCase() === peg$c47) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e47); }
+      if (peg$silentFails === 0) { peg$fail(peg$e51); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -37466,7 +46887,7 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f279();
+            s0 = peg$f387();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -37486,11 +46907,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 8);
-      if (s1.toLowerCase() === peg$c43) {
+      if (s1.toLowerCase() === peg$c47) {
         peg$currPos += (8);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e47); }
+        if (peg$silentFails === 0) { peg$fail(peg$e51); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -37514,7 +46935,7 @@ function peg$parse(input, options) {
           s4 = peg$parseAccessControlSettingsList();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f280(s4);
+            s0 = peg$f388(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -37537,7 +46958,7 @@ function peg$parse(input, options) {
   function peg$parseCreateRowPolicyStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19;
 
-    const key = peg$currPos * 466 + 167;
+    const key = peg$currPos * 508 + 209;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -37548,11 +46969,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -37575,11 +46996,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -37601,11 +47022,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -37649,11 +47070,11 @@ function peg$parse(input, options) {
         s4 = peg$parse_();
         s5 = peg$currPos;
         s6 = input.substr(peg$currPos, 3);
-        if (s6.toLowerCase() === peg$c135) {
+        if (s6.toLowerCase() === peg$c133) {
           peg$currPos += (3);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e141); }
+          if (peg$silentFails === 0) { peg$fail(peg$e142); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -37688,11 +47109,11 @@ function peg$parse(input, options) {
           s5 = null;
         }
         s6 = input.substr(peg$currPos, 6);
-        if (s6.toLowerCase() === peg$c136) {
+        if (s6.toLowerCase() === peg$c134) {
           peg$currPos += (6);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e142); }
+          if (peg$silentFails === 0) { peg$fail(peg$e143); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -37715,11 +47136,11 @@ function peg$parse(input, options) {
             s8 = peg$currPos;
             s9 = peg$parse_();
             s10 = input.substr(peg$currPos, 2);
-            if (s10.toLowerCase() === peg$c149) {
+            if (s10.toLowerCase() === peg$c193) {
               peg$currPos += (2);
             } else {
               s10 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e155); }
+              if (peg$silentFails === 0) { peg$fail(peg$e202); }
             }
             if (s10 !== peg$FAILED) {
               s11 = peg$currPos;
@@ -37741,11 +47162,11 @@ function peg$parse(input, options) {
               if (s11 !== peg$FAILED) {
                 s12 = peg$parse_();
                 s13 = input.substr(peg$currPos, 7);
-                if (s13.toLowerCase() === peg$c70) {
+                if (s13.toLowerCase() === peg$c74) {
                   peg$currPos += (7);
                 } else {
                   s13 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e75); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e79); }
                 }
                 if (s13 !== peg$FAILED) {
                   s14 = peg$currPos;
@@ -37789,11 +47210,11 @@ function peg$parse(input, options) {
             s9 = peg$currPos;
             s10 = peg$parse_();
             s11 = input.substr(peg$currPos, 2);
-            if (s11.toLowerCase() === peg$c25) {
+            if (s11.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s11 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s11 !== peg$FAILED) {
               s12 = peg$currPos;
@@ -37815,11 +47236,11 @@ function peg$parse(input, options) {
               if (s12 !== peg$FAILED) {
                 s13 = peg$parse_();
                 s14 = input.substr(peg$currPos, 3);
-                if (s14.toLowerCase() === peg$c26) {
+                if (s14.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s14 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s14 !== peg$FAILED) {
                   s15 = peg$currPos;
@@ -37841,11 +47262,11 @@ function peg$parse(input, options) {
                   if (s15 !== peg$FAILED) {
                     s16 = peg$parse_();
                     s17 = input.substr(peg$currPos, 6);
-                    if (s17.toLowerCase() === peg$c27) {
+                    if (s17.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s17 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s17 !== peg$FAILED) {
                       s18 = peg$currPos;
@@ -37922,7 +47343,7 @@ function peg$parse(input, options) {
                 }
               }
               peg$savedPos = s0;
-              s0 = peg$f281(s3, s5, s8, s9, s11, s12);
+              s0 = peg$f389(s3, s5, s8, s9, s11, s12);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -37952,7 +47373,7 @@ function peg$parse(input, options) {
   function peg$parseRowPolicyTargets() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 168;
+    const key = peg$currPos * 508 + 210;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -37968,11 +47389,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -37993,11 +47414,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -38015,7 +47436,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f282(s1, s2);
+      s0 = peg$f390(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -38029,7 +47450,7 @@ function peg$parse(input, options) {
   function peg$parseRowPolicyTarget() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 169;
+    const key = peg$currPos * 508 + 211;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -38056,11 +47477,11 @@ function peg$parse(input, options) {
       }
       s3 = peg$parse_();
       s4 = input.substr(peg$currPos, 2);
-      if (s4.toLowerCase() === peg$c103) {
+      if (s4.toLowerCase() === peg$c94) {
         peg$currPos += (2);
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e108); }
+        if (peg$silentFails === 0) { peg$fail(peg$e99); }
       }
       if (s4 !== peg$FAILED) {
         s5 = peg$currPos;
@@ -38084,7 +47505,7 @@ function peg$parse(input, options) {
           s7 = peg$parseRowPolicyTableList();
           if (s7 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f283(s1, s2, s7);
+            s0 = peg$f391(s1, s2, s7);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -38110,7 +47531,7 @@ function peg$parse(input, options) {
   function peg$parseRowPolicyTableList() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 170;
+    const key = peg$currPos * 508 + 212;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -38126,11 +47547,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -38166,11 +47587,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -38203,7 +47624,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f284(s1, s2);
+      s0 = peg$f392(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -38217,7 +47638,7 @@ function peg$parse(input, options) {
   function peg$parseRowPolicyTableRef() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 171;
+    const key = peg$currPos * 508 + 213;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -38234,25 +47655,25 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 46) {
-        s3 = peg$c35;
+        s3 = peg$c39;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 42) {
-          s6 = peg$c185;
+          s6 = peg$c123;
           peg$currPos++;
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e195); }
+          if (peg$silentFails === 0) { peg$fail(peg$e130); }
         }
         if (s6 !== peg$FAILED) {
           peg$savedPos = s5;
-          s6 = peg$f285(s1);
+          s6 = peg$f393(s1);
         }
         s5 = s6;
         if (s5 === peg$FAILED) {
@@ -38263,7 +47684,7 @@ function peg$parse(input, options) {
         }
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f286(s1, s5);
+          s0 = peg$f394(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -38284,7 +47705,7 @@ function peg$parse(input, options) {
       }
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f287(s1);
+        s1 = peg$f395(s1);
       }
       s0 = s1;
     }
@@ -38297,7 +47718,7 @@ function peg$parse(input, options) {
   function peg$parseRowPolicyTargetLookahead() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 172;
+    const key = peg$currPos * 508 + 214;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -38311,11 +47732,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       s3 = input.substr(peg$currPos, 2);
-      if (s3.toLowerCase() === peg$c103) {
+      if (s3.toLowerCase() === peg$c94) {
         peg$currPos += (2);
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e108); }
+        if (peg$silentFails === 0) { peg$fail(peg$e99); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$currPos;
@@ -38358,7 +47779,7 @@ function peg$parse(input, options) {
   function peg$parseRowPolicyNameList() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 173;
+    const key = peg$currPos * 508 + 215;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -38374,11 +47795,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -38389,11 +47810,11 @@ function peg$parse(input, options) {
           s9 = peg$currPos;
           s10 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 46) {
-            s11 = peg$c35;
+            s11 = peg$c39;
             peg$currPos++;
           } else {
             s11 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e39); }
+            if (peg$silentFails === 0) { peg$fail(peg$e43); }
           }
           if (s11 !== peg$FAILED) {
             s10 = [s10, s11];
@@ -38429,11 +47850,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -38444,11 +47865,11 @@ function peg$parse(input, options) {
             s9 = peg$currPos;
             s10 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 46) {
-              s11 = peg$c35;
+              s11 = peg$c39;
               peg$currPos++;
             } else {
               s11 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e39); }
+              if (peg$silentFails === 0) { peg$fail(peg$e43); }
             }
             if (s11 !== peg$FAILED) {
               s10 = [s10, s11];
@@ -38481,7 +47902,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f288(s1, s2);
+      s0 = peg$f396(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -38495,7 +47916,7 @@ function peg$parse(input, options) {
   function peg$parseRowPolicyClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 174;
+    const key = peg$currPos * 508 + 216;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -38506,11 +47927,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c186) {
+    if (s1.toLowerCase() === peg$c122) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e196); }
+      if (peg$silentFails === 0) { peg$fail(peg$e128); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -38532,11 +47953,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c131) {
+        if (s4.toLowerCase() === peg$c135) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e137); }
+          if (peg$silentFails === 0) { peg$fail(peg$e144); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -38557,7 +47978,7 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f289();
+            s0 = peg$f397();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -38577,11 +47998,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c187) {
+      if (s1.toLowerCase() === peg$c136) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e197); }
+        if (peg$silentFails === 0) { peg$fail(peg$e145); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -38605,7 +48026,7 @@ function peg$parse(input, options) {
           s4 = peg$parseExpression();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f290(s4);
+            s0 = peg$f398(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -38647,19 +48068,19 @@ function peg$parse(input, options) {
           if (s2 !== peg$FAILED) {
             s3 = peg$parse_();
             s4 = input.substr(peg$currPos, 11);
-            if (s4.toLowerCase() === peg$c188) {
+            if (s4.toLowerCase() === peg$c137) {
               peg$currPos += (11);
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e198); }
+              if (peg$silentFails === 0) { peg$fail(peg$e146); }
             }
             if (s4 === peg$FAILED) {
               s4 = input.substr(peg$currPos, 10);
-              if (s4.toLowerCase() === peg$c189) {
+              if (s4.toLowerCase() === peg$c138) {
                 peg$currPos += (10);
               } else {
                 s4 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e199); }
+                if (peg$silentFails === 0) { peg$fail(peg$e147); }
               }
             }
             if (s4 !== peg$FAILED) {
@@ -38681,7 +48102,7 @@ function peg$parse(input, options) {
               }
               if (s5 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f291(s4);
+                s0 = peg$f399(s4);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -38729,7 +48150,7 @@ function peg$parse(input, options) {
               s4 = peg$parseSetRoleList();
               if (s4 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f292(s4);
+                s0 = peg$f400(s4);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -38745,11 +48166,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 2);
-            if (s1.toLowerCase() === peg$c103) {
+            if (s1.toLowerCase() === peg$c94) {
               peg$currPos += (2);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e108); }
+              if (peg$silentFails === 0) { peg$fail(peg$e99); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -38771,11 +48192,11 @@ function peg$parse(input, options) {
               if (s2 !== peg$FAILED) {
                 s3 = peg$parse_();
                 s4 = input.substr(peg$currPos, 7);
-                if (s4.toLowerCase() === peg$c170) {
+                if (s4.toLowerCase() === peg$c139) {
                   peg$currPos += (7);
                 } else {
                   s4 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e176); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e148); }
                 }
                 if (s4 !== peg$FAILED) {
                   s5 = peg$currPos;
@@ -38800,7 +48221,7 @@ function peg$parse(input, options) {
                     s8 = peg$parseStringLiteral();
                     if (s8 !== peg$FAILED) {
                       peg$savedPos = s7;
-                      s8 = peg$f293();
+                      s8 = peg$f401();
                     }
                     s7 = s8;
                     if (s7 === peg$FAILED) {
@@ -38808,7 +48229,7 @@ function peg$parse(input, options) {
                     }
                     if (s7 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f294(s7);
+                      s0 = peg$f402(s7);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -38842,7 +48263,7 @@ function peg$parse(input, options) {
   function peg$parseCreateQuotaStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
 
-    const key = peg$currPos * 466 + 175;
+    const key = peg$currPos * 508 + 217;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -38853,11 +48274,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -38880,11 +48301,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -38906,11 +48327,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -38953,11 +48374,11 @@ function peg$parse(input, options) {
         }
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 5);
-        if (s5.toLowerCase() === peg$c134) {
+        if (s5.toLowerCase() === peg$c132) {
           peg$currPos += (5);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e140); }
+          if (peg$silentFails === 0) { peg$fail(peg$e141); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -38980,11 +48401,11 @@ function peg$parse(input, options) {
             s7 = peg$currPos;
             s8 = peg$parse_();
             s9 = input.substr(peg$currPos, 2);
-            if (s9.toLowerCase() === peg$c25) {
+            if (s9.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s9 !== peg$FAILED) {
               s10 = peg$currPos;
@@ -39006,11 +48427,11 @@ function peg$parse(input, options) {
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 3);
-                if (s12.toLowerCase() === peg$c26) {
+                if (s12.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -39032,11 +48453,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 6);
-                    if (s15.toLowerCase() === peg$c27) {
+                    if (s15.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -39092,11 +48513,11 @@ function peg$parse(input, options) {
               s11 = peg$currPos;
               s12 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s13 = peg$c15;
+                s13 = peg$c24;
                 peg$currPos++;
               } else {
                 s13 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s13 === peg$FAILED) {
                 s13 = null;
@@ -39115,11 +48536,11 @@ function peg$parse(input, options) {
                 s11 = peg$currPos;
                 s12 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s13 = peg$c15;
+                  s13 = peg$c24;
                   peg$currPos++;
                 } else {
                   s13 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s13 === peg$FAILED) {
                   s13 = null;
@@ -39135,7 +48556,7 @@ function peg$parse(input, options) {
                 }
               }
               peg$savedPos = s0;
-              s0 = peg$f295(s3, s7, s9, s10);
+              s0 = peg$f403(s3, s7, s9, s10);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -39165,7 +48586,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaNameList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 176;
+    const key = peg$currPos * 508 + 218;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -39181,11 +48602,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -39206,11 +48627,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -39228,7 +48649,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f296(s1, s2);
+      s0 = peg$f404(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -39242,7 +48663,7 @@ function peg$parse(input, options) {
   function peg$parseAccessControlNameValue() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 177;
+    const key = peg$currPos * 508 + 219;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -39253,11 +48674,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 39) {
-      s1 = peg$c108;
+      s1 = peg$c99;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e113); }
+      if (peg$silentFails === 0) { peg$fail(peg$e104); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
@@ -39267,15 +48688,15 @@ function peg$parse(input, options) {
         s3 = peg$parseSingleQuotedUserChar();
       }
       if (input.charCodeAt(peg$currPos) === 39) {
-        s3 = peg$c108;
+        s3 = peg$c99;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e113); }
+        if (peg$silentFails === 0) { peg$fail(peg$e104); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f297(s2);
+        s0 = peg$f405(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -39296,7 +48717,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaClause() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 178;
+    const key = peg$currPos * 508 + 220;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -39339,7 +48760,7 @@ function peg$parse(input, options) {
             s4 = peg$parseSetRoleList();
             if (s4 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f298(s4);
+              s0 = peg$f406(s4);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -39363,7 +48784,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaKeyedClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 179;
+    const key = peg$currPos * 508 + 221;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -39374,11 +48795,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c26) {
+    if (s1.toLowerCase() === peg$c30) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e30); }
+      if (peg$silentFails === 0) { peg$fail(peg$e34); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -39400,11 +48821,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c190) {
+        if (s4.toLowerCase() === peg$c223) {
           peg$currPos += (5);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e200); }
+          if (peg$silentFails === 0) { peg$fail(peg$e235); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -39425,7 +48846,7 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f299();
+            s0 = peg$f407();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -39445,19 +48866,19 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c190) {
+      if (s1.toLowerCase() === peg$c223) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e200); }
+        if (peg$silentFails === 0) { peg$fail(peg$e235); }
       }
       if (s1 === peg$FAILED) {
         s1 = input.substr(peg$currPos, 3);
-        if (s1.toLowerCase() === peg$c49) {
+        if (s1.toLowerCase() === peg$c53) {
           peg$currPos += (3);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e54); }
+          if (peg$silentFails === 0) { peg$fail(peg$e58); }
         }
       }
       if (s1 !== peg$FAILED) {
@@ -39480,11 +48901,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 2);
-          if (s4.toLowerCase() === peg$c80) {
+          if (s4.toLowerCase() === peg$c84) {
             peg$currPos += (2);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e85); }
+            if (peg$silentFails === 0) { peg$fail(peg$e89); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -39508,7 +48929,7 @@ function peg$parse(input, options) {
               s7 = peg$parseQuotaKeyList();
               if (s7 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f300(s7);
+                s0 = peg$f408(s7);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -39539,7 +48960,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaKeyList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 180;
+    const key = peg$currPos * 508 + 222;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -39555,11 +48976,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -39580,11 +49001,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -39602,7 +49023,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f301(s1, s2);
+      s0 = peg$f409(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -39616,7 +49037,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaKeyName() {
     let s0, s1;
 
-    const key = peg$currPos * 466 + 181;
+    const key = peg$currPos * 508 + 223;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -39629,7 +49050,7 @@ function peg$parse(input, options) {
     s1 = peg$parseStringLiteral();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f302();
+      s1 = peg$f410();
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
@@ -39644,7 +49065,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaIntervalClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 182;
+    const key = peg$currPos * 508 + 224;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -39655,11 +49076,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c186) {
+    if (s1.toLowerCase() === peg$c122) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e196); }
+      if (peg$silentFails === 0) { peg$fail(peg$e128); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -39682,11 +49103,11 @@ function peg$parse(input, options) {
         s3 = peg$parse_();
         s4 = peg$currPos;
         s5 = input.substr(peg$currPos, 10);
-        if (s5.toLowerCase() === peg$c191) {
+        if (s5.toLowerCase() === peg$c224) {
           peg$currPos += (10);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e201); }
+          if (peg$silentFails === 0) { peg$fail(peg$e236); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -39722,11 +49143,11 @@ function peg$parse(input, options) {
         }
         s5 = peg$currPos;
         s6 = input.substr(peg$currPos, 8);
-        if (s6.toLowerCase() === peg$c192) {
+        if (s6.toLowerCase() === peg$c225) {
           peg$currPos += (8);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e202); }
+          if (peg$silentFails === 0) { peg$fail(peg$e237); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -39779,7 +49200,7 @@ function peg$parse(input, options) {
               s9 = null;
             }
             peg$savedPos = s0;
-            s0 = peg$f303(s4, s6, s8, s9);
+            s0 = peg$f411(s4, s6, s8, s9);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -39805,7 +49226,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaDuration() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 183;
+    const key = peg$currPos * 508 + 225;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -39841,11 +49262,11 @@ function peg$parse(input, options) {
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 46) {
-        s4 = peg$c35;
+        s4 = peg$c39;
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s4 !== peg$FAILED) {
         s5 = [];
@@ -39904,7 +49325,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaTimeUnit() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 184;
+    const key = peg$currPos * 508 + 226;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -39915,67 +49336,67 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c193) {
+    if (s1.toLowerCase() === peg$c226) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e203); }
+      if (peg$silentFails === 0) { peg$fail(peg$e238); }
     }
     if (s1 === peg$FAILED) {
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c194) {
+      if (s1.toLowerCase() === peg$c227) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e204); }
+        if (peg$silentFails === 0) { peg$fail(peg$e239); }
       }
       if (s1 === peg$FAILED) {
         s1 = input.substr(peg$currPos, 4);
-        if (s1.toLowerCase() === peg$c195) {
+        if (s1.toLowerCase() === peg$c228) {
           peg$currPos += (4);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e205); }
+          if (peg$silentFails === 0) { peg$fail(peg$e240); }
         }
         if (s1 === peg$FAILED) {
           s1 = input.substr(peg$currPos, 3);
-          if (s1.toLowerCase() === peg$c196) {
+          if (s1.toLowerCase() === peg$c229) {
             peg$currPos += (3);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e206); }
+            if (peg$silentFails === 0) { peg$fail(peg$e241); }
           }
           if (s1 === peg$FAILED) {
             s1 = input.substr(peg$currPos, 4);
-            if (s1.toLowerCase() === peg$c197) {
+            if (s1.toLowerCase() === peg$c230) {
               peg$currPos += (4);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e207); }
+              if (peg$silentFails === 0) { peg$fail(peg$e242); }
             }
             if (s1 === peg$FAILED) {
               s1 = input.substr(peg$currPos, 5);
-              if (s1.toLowerCase() === peg$c198) {
+              if (s1.toLowerCase() === peg$c231) {
                 peg$currPos += (5);
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e208); }
+                if (peg$silentFails === 0) { peg$fail(peg$e243); }
               }
               if (s1 === peg$FAILED) {
                 s1 = input.substr(peg$currPos, 7);
-                if (s1.toLowerCase() === peg$c199) {
+                if (s1.toLowerCase() === peg$c232) {
                   peg$currPos += (7);
                 } else {
                   s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e209); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e244); }
                 }
                 if (s1 === peg$FAILED) {
                   s1 = input.substr(peg$currPos, 4);
-                  if (s1.toLowerCase() === peg$c200) {
+                  if (s1.toLowerCase() === peg$c233) {
                     peg$currPos += (4);
                   } else {
                     s1 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e210); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e245); }
                   }
                 }
               }
@@ -39986,11 +49407,11 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (s2.toLowerCase() === peg$c201) {
+      if (s2.toLowerCase() === peg$c234) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e211); }
+        if (peg$silentFails === 0) { peg$fail(peg$e246); }
       }
       if (s2 === peg$FAILED) {
         s2 = null;
@@ -40013,7 +49434,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f304();
+        s0 = peg$f412();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -40031,7 +49452,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaIntervalBody() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 185;
+    const key = peg$currPos * 508 + 227;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -40042,11 +49463,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c202) {
+    if (s1.toLowerCase() === peg$c235) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e212); }
+      if (peg$silentFails === 0) { peg$fail(peg$e247); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -40068,11 +49489,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 4);
-        if (s4.toLowerCase() === peg$c203) {
+        if (s4.toLowerCase() === peg$c236) {
           peg$currPos += (4);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e213); }
+          if (peg$silentFails === 0) { peg$fail(peg$e248); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -40093,7 +49514,7 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f305();
+            s0 = peg$f413();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -40113,11 +49534,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 2);
-      if (s1.toLowerCase() === peg$c106) {
+      if (s1.toLowerCase() === peg$c97) {
         peg$currPos += (2);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e111); }
+        if (peg$silentFails === 0) { peg$fail(peg$e102); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -40139,11 +49560,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 6);
-          if (s4.toLowerCase() === peg$c204) {
+          if (s4.toLowerCase() === peg$c237) {
             peg$currPos += (6);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e214); }
+            if (peg$silentFails === 0) { peg$fail(peg$e249); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -40164,7 +49585,7 @@ function peg$parse(input, options) {
             }
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f306();
+              s0 = peg$f414();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -40186,7 +49607,7 @@ function peg$parse(input, options) {
         s1 = peg$parseQuotaLimitList();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f307(s1);
+          s1 = peg$f415(s1);
         }
         s0 = s1;
       }
@@ -40200,7 +49621,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaLimitList() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 186;
+    const key = peg$currPos * 508 + 228;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -40216,11 +49637,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -40256,11 +49677,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -40293,7 +49714,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f308(s1, s2);
+      s0 = peg$f416(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -40307,7 +49728,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaLimitListEnd() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 187;
+    const key = peg$currPos * 508 + 229;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -40318,11 +49739,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c186) {
+    if (s1.toLowerCase() === peg$c122) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e196); }
+      if (peg$silentFails === 0) { peg$fail(peg$e128); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -40392,11 +49813,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 5);
-        if (s1.toLowerCase() === peg$c190) {
+        if (s1.toLowerCase() === peg$c223) {
           peg$currPos += (5);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e200); }
+          if (peg$silentFails === 0) { peg$fail(peg$e235); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -40429,11 +49850,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 3);
-          if (s1.toLowerCase() === peg$c49) {
+          if (s1.toLowerCase() === peg$c53) {
             peg$currPos += (3);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e54); }
+            if (peg$silentFails === 0) { peg$fail(peg$e58); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -40466,11 +49887,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 3);
-            if (s1.toLowerCase() === peg$c26) {
+            if (s1.toLowerCase() === peg$c30) {
               peg$currPos += (3);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e30); }
+              if (peg$silentFails === 0) { peg$fail(peg$e34); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -40492,11 +49913,11 @@ function peg$parse(input, options) {
               if (s2 !== peg$FAILED) {
                 s3 = peg$parse_();
                 s4 = input.substr(peg$currPos, 5);
-                if (s4.toLowerCase() === peg$c190) {
+                if (s4.toLowerCase() === peg$c223) {
                   peg$currPos += (5);
                 } else {
                   s4 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e200); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e235); }
                 }
                 if (s4 !== peg$FAILED) {
                   s5 = peg$currPos;
@@ -40547,7 +49968,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaLimitItem() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 188;
+    const key = peg$currPos * 508 + 230;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -40558,11 +49979,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c163) {
+    if (s1.toLowerCase() === peg$c207) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e169); }
+      if (peg$silentFails === 0) { peg$fail(peg$e216); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -40588,11 +50009,11 @@ function peg$parse(input, options) {
           s5 = peg$parse_();
           s6 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 61) {
-            s7 = peg$c62;
+            s7 = peg$c66;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e67); }
+            if (peg$silentFails === 0) { peg$fail(peg$e71); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$parse_();
@@ -40608,7 +50029,7 @@ function peg$parse(input, options) {
           s7 = peg$parseExpression();
           if (s7 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f309(s4, s7);
+            s0 = peg$f417(s4, s7);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -40631,11 +50052,11 @@ function peg$parse(input, options) {
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         s3 = input.substr(peg$currPos, 3);
-        if (s3.toLowerCase() === peg$c163) {
+        if (s3.toLowerCase() === peg$c207) {
           peg$currPos += (3);
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e169); }
+          if (peg$silentFails === 0) { peg$fail(peg$e216); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$currPos;
@@ -40659,7 +50080,7 @@ function peg$parse(input, options) {
             s6 = peg$parseExpression();
             if (s6 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f310(s1, s6);
+              s0 = peg$f418(s1, s6);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -40682,18 +50103,18 @@ function peg$parse(input, options) {
         if (s1 !== peg$FAILED) {
           s2 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 61) {
-            s3 = peg$c62;
+            s3 = peg$c66;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e67); }
+            if (peg$silentFails === 0) { peg$fail(peg$e71); }
           }
           if (s3 !== peg$FAILED) {
             s4 = peg$parse_();
             s5 = peg$parseExpression();
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f311(s1, s5);
+              s0 = peg$f419(s1, s5);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -40714,7 +50135,7 @@ function peg$parse(input, options) {
             s3 = peg$parseExpression();
             if (s3 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f312(s1, s3);
+              s0 = peg$f420(s1, s3);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -40735,7 +50156,7 @@ function peg$parse(input, options) {
   function peg$parseQuotaLimitName() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 189;
+    const key = peg$currPos * 508 + 231;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -40746,67 +50167,67 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c205) {
+    if (s1.toLowerCase() === peg$c238) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e215); }
+      if (peg$silentFails === 0) { peg$fail(peg$e250); }
     }
     if (s1 === peg$FAILED) {
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c206) {
+      if (s1.toLowerCase() === peg$c239) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e216); }
+        if (peg$silentFails === 0) { peg$fail(peg$e251); }
       }
       if (s1 === peg$FAILED) {
         s1 = input.substr(peg$currPos, 9);
-        if (s1.toLowerCase() === peg$c207) {
+        if (s1.toLowerCase() === peg$c240) {
           peg$currPos += (9);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e217); }
+          if (peg$silentFails === 0) { peg$fail(peg$e252); }
         }
       }
     }
     if (s1 !== peg$FAILED) {
       if (input.charCodeAt(peg$currPos) === 32) {
-        s2 = peg$c208;
+        s2 = peg$c241;
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e218); }
+        if (peg$silentFails === 0) { peg$fail(peg$e253); }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.substr(peg$currPos, 4);
-        if (s3.toLowerCase() === peg$c209) {
+        if (s3.toLowerCase() === peg$c242) {
           peg$currPos += (4);
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e219); }
+          if (peg$silentFails === 0) { peg$fail(peg$e254); }
         }
         if (s3 === peg$FAILED) {
           s3 = input.substr(peg$currPos, 5);
-          if (s3.toLowerCase() === peg$c210) {
+          if (s3.toLowerCase() === peg$c243) {
             peg$currPos += (5);
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e220); }
+            if (peg$silentFails === 0) { peg$fail(peg$e255); }
           }
           if (s3 === peg$FAILED) {
             s3 = input.substr(peg$currPos, 4);
-            if (s3.toLowerCase() === peg$c211) {
+            if (s3.toLowerCase() === peg$c244) {
               peg$currPos += (4);
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e221); }
+              if (peg$silentFails === 0) { peg$fail(peg$e256); }
             }
           }
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f313();
+          s0 = peg$f421();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -40824,21 +50245,21 @@ function peg$parse(input, options) {
       s1 = peg$currPos;
       s2 = [];
       s3 = input.charAt(peg$currPos);
-      if (peg$r8.test(s3)) {
+      if (peg$r5.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e184); }
+        if (peg$silentFails === 0) { peg$fail(peg$e129); }
       }
       if (s3 !== peg$FAILED) {
         while (s3 !== peg$FAILED) {
           s2.push(s3);
           s3 = input.charAt(peg$currPos);
-          if (peg$r8.test(s3)) {
+          if (peg$r5.test(s3)) {
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e184); }
+            if (peg$silentFails === 0) { peg$fail(peg$e129); }
           }
         }
       } else {
@@ -40848,30 +50269,30 @@ function peg$parse(input, options) {
         s3 = [];
         s4 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 95) {
-          s5 = peg$c212;
+          s5 = peg$c245;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e222); }
+          if (peg$silentFails === 0) { peg$fail(peg$e257); }
         }
         if (s5 !== peg$FAILED) {
           s6 = [];
           s7 = input.charAt(peg$currPos);
-          if (peg$r8.test(s7)) {
+          if (peg$r5.test(s7)) {
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e184); }
+            if (peg$silentFails === 0) { peg$fail(peg$e129); }
           }
           if (s7 !== peg$FAILED) {
             while (s7 !== peg$FAILED) {
               s6.push(s7);
               s7 = input.charAt(peg$currPos);
-              if (peg$r8.test(s7)) {
+              if (peg$r5.test(s7)) {
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e184); }
+                if (peg$silentFails === 0) { peg$fail(peg$e129); }
               }
             }
           } else {
@@ -40892,30 +50313,30 @@ function peg$parse(input, options) {
           s3.push(s4);
           s4 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 95) {
-            s5 = peg$c212;
+            s5 = peg$c245;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e222); }
+            if (peg$silentFails === 0) { peg$fail(peg$e257); }
           }
           if (s5 !== peg$FAILED) {
             s6 = [];
             s7 = input.charAt(peg$currPos);
-            if (peg$r8.test(s7)) {
+            if (peg$r5.test(s7)) {
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e184); }
+              if (peg$silentFails === 0) { peg$fail(peg$e129); }
             }
             if (s7 !== peg$FAILED) {
               while (s7 !== peg$FAILED) {
                 s6.push(s7);
                 s7 = input.charAt(peg$currPos);
-                if (peg$r8.test(s7)) {
+                if (peg$r5.test(s7)) {
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e184); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e129); }
                 }
               }
             } else {
@@ -40954,7 +50375,7 @@ function peg$parse(input, options) {
   function peg$parseCreateSettingsProfileStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19;
 
-    const key = peg$currPos * 466 + 190;
+    const key = peg$currPos * 508 + 232;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -40965,11 +50386,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -40992,11 +50413,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -41018,11 +50439,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -41066,11 +50487,11 @@ function peg$parse(input, options) {
         s4 = peg$parse_();
         s5 = peg$currPos;
         s6 = input.substr(peg$currPos, 8);
-        if (s6.toLowerCase() === peg$c43) {
+        if (s6.toLowerCase() === peg$c47) {
           peg$currPos += (8);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e47); }
+          if (peg$silentFails === 0) { peg$fail(peg$e51); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -41105,11 +50526,11 @@ function peg$parse(input, options) {
           s5 = null;
         }
         s6 = input.substr(peg$currPos, 7);
-        if (s6.toLowerCase() === peg$c137) {
+        if (s6.toLowerCase() === peg$c140) {
           peg$currPos += (7);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e143); }
+          if (peg$silentFails === 0) { peg$fail(peg$e149); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -41132,11 +50553,11 @@ function peg$parse(input, options) {
             s8 = peg$currPos;
             s9 = peg$parse_();
             s10 = input.substr(peg$currPos, 2);
-            if (s10.toLowerCase() === peg$c149) {
+            if (s10.toLowerCase() === peg$c193) {
               peg$currPos += (2);
             } else {
               s10 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e155); }
+              if (peg$silentFails === 0) { peg$fail(peg$e202); }
             }
             if (s10 !== peg$FAILED) {
               s11 = peg$currPos;
@@ -41158,11 +50579,11 @@ function peg$parse(input, options) {
               if (s11 !== peg$FAILED) {
                 s12 = peg$parse_();
                 s13 = input.substr(peg$currPos, 7);
-                if (s13.toLowerCase() === peg$c70) {
+                if (s13.toLowerCase() === peg$c74) {
                   peg$currPos += (7);
                 } else {
                   s13 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e75); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e79); }
                 }
                 if (s13 !== peg$FAILED) {
                   s14 = peg$currPos;
@@ -41206,11 +50627,11 @@ function peg$parse(input, options) {
             s9 = peg$currPos;
             s10 = peg$parse_();
             s11 = input.substr(peg$currPos, 2);
-            if (s11.toLowerCase() === peg$c25) {
+            if (s11.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s11 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s11 !== peg$FAILED) {
               s12 = peg$currPos;
@@ -41232,11 +50653,11 @@ function peg$parse(input, options) {
               if (s12 !== peg$FAILED) {
                 s13 = peg$parse_();
                 s14 = input.substr(peg$currPos, 3);
-                if (s14.toLowerCase() === peg$c26) {
+                if (s14.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s14 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s14 !== peg$FAILED) {
                   s15 = peg$currPos;
@@ -41258,11 +50679,11 @@ function peg$parse(input, options) {
                   if (s15 !== peg$FAILED) {
                     s16 = peg$parse_();
                     s17 = input.substr(peg$currPos, 6);
-                    if (s17.toLowerCase() === peg$c27) {
+                    if (s17.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s17 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s17 !== peg$FAILED) {
                       s18 = peg$currPos;
@@ -41375,7 +50796,7 @@ function peg$parse(input, options) {
                 s13 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f314(s3, s5, s8, s9, s11, s12, s13);
+              s0 = peg$f422(s3, s5, s8, s9, s11, s12, s13);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -41405,7 +50826,7 @@ function peg$parse(input, options) {
   function peg$parseCreateNamedCollectionStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20;
 
-    const key = peg$currPos * 466 + 191;
+    const key = peg$currPos * 508 + 233;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -41416,11 +50837,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -41443,11 +50864,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -41469,11 +50890,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -41516,11 +50937,11 @@ function peg$parse(input, options) {
         }
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 5);
-        if (s5.toLowerCase() === peg$c138) {
+        if (s5.toLowerCase() === peg$c114) {
           peg$currPos += (5);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e144); }
+          if (peg$silentFails === 0) { peg$fail(peg$e120); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -41542,11 +50963,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 10);
-            if (s8.toLowerCase() === peg$c139) {
+            if (s8.toLowerCase() === peg$c115) {
               peg$currPos += (10);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e145); }
+              if (peg$silentFails === 0) { peg$fail(peg$e121); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -41569,11 +50990,11 @@ function peg$parse(input, options) {
                 s10 = peg$currPos;
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 2);
-                if (s12.toLowerCase() === peg$c25) {
+                if (s12.toLowerCase() === peg$c29) {
                   peg$currPos += (2);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e33); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -41595,11 +51016,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 3);
-                    if (s15.toLowerCase() === peg$c26) {
+                    if (s15.toLowerCase() === peg$c30) {
                       peg$currPos += (3);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e34); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -41621,11 +51042,11 @@ function peg$parse(input, options) {
                       if (s16 !== peg$FAILED) {
                         s17 = peg$parse_();
                         s18 = input.substr(peg$currPos, 6);
-                        if (s18.toLowerCase() === peg$c27) {
+                        if (s18.toLowerCase() === peg$c31) {
                           peg$currPos += (6);
                         } else {
                           s18 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e35); }
                         }
                         if (s18 !== peg$FAILED) {
                           s19 = peg$currPos;
@@ -41720,7 +51141,7 @@ function peg$parse(input, options) {
                       s18 = peg$parseNamedCollectionItemList();
                       if (s18 !== peg$FAILED) {
                         peg$savedPos = s0;
-                        s0 = peg$f315(s3, s10, s12, s13, s18);
+                        s0 = peg$f423(s3, s10, s12, s13, s18);
                       } else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
@@ -41770,7 +51191,7 @@ function peg$parse(input, options) {
   function peg$parseNamedCollectionItemList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 192;
+    const key = peg$currPos * 508 + 234;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -41786,11 +51207,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -41811,11 +51232,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -41833,7 +51254,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f316(s1, s2);
+      s0 = peg$f424(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -41847,7 +51268,7 @@ function peg$parse(input, options) {
   function peg$parseNamedCollectionItem() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 193;
+    const key = peg$currPos * 508 + 235;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -41861,18 +51282,18 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 61) {
-        s3 = peg$c62;
+        s3 = peg$c66;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e67); }
+        if (peg$silentFails === 0) { peg$fail(peg$e71); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$parseExpression();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f317(s1, s5);
+          s0 = peg$f425(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -41894,7 +51315,7 @@ function peg$parse(input, options) {
   function peg$parseCreateResourceStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
 
-    const key = peg$currPos * 466 + 194;
+    const key = peg$currPos * 508 + 236;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -41905,11 +51326,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -41932,11 +51353,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -41958,11 +51379,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -42005,11 +51426,11 @@ function peg$parse(input, options) {
         }
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 8);
-        if (s5.toLowerCase() === peg$c141) {
+        if (s5.toLowerCase() === peg$c186) {
           peg$currPos += (8);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e147); }
+          if (peg$silentFails === 0) { peg$fail(peg$e195); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -42032,11 +51453,11 @@ function peg$parse(input, options) {
             s7 = peg$currPos;
             s8 = peg$parse_();
             s9 = input.substr(peg$currPos, 2);
-            if (s9.toLowerCase() === peg$c25) {
+            if (s9.toLowerCase() === peg$c29) {
               peg$currPos += (2);
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
             if (s9 !== peg$FAILED) {
               s10 = peg$currPos;
@@ -42058,11 +51479,11 @@ function peg$parse(input, options) {
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
                 s12 = input.substr(peg$currPos, 3);
-                if (s12.toLowerCase() === peg$c26) {
+                if (s12.toLowerCase() === peg$c30) {
                   peg$currPos += (3);
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e34); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -42084,11 +51505,11 @@ function peg$parse(input, options) {
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
                     s15 = input.substr(peg$currPos, 6);
-                    if (s15.toLowerCase() === peg$c27) {
+                    if (s15.toLowerCase() === peg$c31) {
                       peg$currPos += (6);
                     } else {
                       s15 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e35); }
                     }
                     if (s15 !== peg$FAILED) {
                       s16 = peg$currPos;
@@ -42142,11 +51563,11 @@ function peg$parse(input, options) {
             if (s9 !== peg$FAILED) {
               s10 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 40) {
-                s11 = peg$c21;
+                s11 = peg$c25;
                 peg$currPos++;
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                if (peg$silentFails === 0) { peg$fail(peg$e29); }
               }
               if (s11 !== peg$FAILED) {
                 s12 = peg$parse_();
@@ -42154,15 +51575,15 @@ function peg$parse(input, options) {
                 if (s13 !== peg$FAILED) {
                   s14 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 41) {
-                    s15 = peg$c22;
+                    s15 = peg$c26;
                     peg$currPos++;
                   } else {
                     s15 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
                   }
                   if (s15 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f318(s3, s7, s9, s13);
+                    s0 = peg$f426(s3, s7, s9, s13);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -42204,7 +51625,7 @@ function peg$parse(input, options) {
   function peg$parseResourceSpecList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 195;
+    const key = peg$currPos * 508 + 237;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -42220,11 +51641,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -42245,11 +51666,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -42267,7 +51688,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f319(s1, s2);
+      s0 = peg$f427(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -42281,7 +51702,7 @@ function peg$parse(input, options) {
   function peg$parseResourceSpec() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 196;
+    const key = peg$currPos * 508 + 238;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -42293,19 +51714,19 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$currPos;
     s2 = input.substr(peg$currPos, 4);
-    if (s2.toLowerCase() === peg$c206) {
+    if (s2.toLowerCase() === peg$c239) {
       peg$currPos += (4);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e216); }
+      if (peg$silentFails === 0) { peg$fail(peg$e251); }
     }
     if (s2 === peg$FAILED) {
       s2 = input.substr(peg$currPos, 5);
-      if (s2.toLowerCase() === peg$c213) {
+      if (s2.toLowerCase() === peg$c246) {
         peg$currPos += (5);
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e223); }
+        if (peg$silentFails === 0) { peg$fail(peg$e258); }
       }
     }
     if (s2 !== peg$FAILED) {
@@ -42334,19 +51755,19 @@ function peg$parse(input, options) {
         s3 = peg$parse_();
         s4 = peg$currPos;
         s5 = input.substr(peg$currPos, 4);
-        if (s5.toLowerCase() === peg$c72) {
+        if (s5.toLowerCase() === peg$c76) {
           peg$currPos += (4);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e77); }
+          if (peg$silentFails === 0) { peg$fail(peg$e81); }
         }
         if (s5 === peg$FAILED) {
           s5 = input.substr(peg$currPos, 3);
-          if (s5.toLowerCase() === peg$c177) {
+          if (s5.toLowerCase() === peg$c215) {
             peg$currPos += (3);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e187); }
+            if (peg$silentFails === 0) { peg$fail(peg$e227); }
           }
         }
         if (s5 !== peg$FAILED) {
@@ -42376,7 +51797,7 @@ function peg$parse(input, options) {
             s7 = peg$parseAliasName();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f320(s1, s4, s7);
+              s0 = peg$f428(s1, s4, s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -42406,7 +51827,7 @@ function peg$parse(input, options) {
   function peg$parseCreateWindowViewStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14;
 
-    const key = peg$currPos * 466 + 197;
+    const key = peg$currPos * 508 + 239;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -42417,11 +51838,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -42444,11 +51865,11 @@ function peg$parse(input, options) {
         s3 = peg$parse_();
         s4 = peg$currPos;
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -42470,11 +51891,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -42517,11 +51938,11 @@ function peg$parse(input, options) {
           s4 = null;
         }
         s5 = input.substr(peg$currPos, 6);
-        if (s5.toLowerCase() === peg$c214) {
+        if (s5.toLowerCase() === peg$c247) {
           peg$currPos += (6);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e224); }
+          if (peg$silentFails === 0) { peg$fail(peg$e259); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -42543,11 +51964,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 4);
-            if (s8.toLowerCase() === peg$c112) {
+            if (s8.toLowerCase() === peg$c111) {
               peg$currPos += (4);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e118); }
+              if (peg$silentFails === 0) { peg$fail(peg$e117); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -42573,11 +51994,11 @@ function peg$parse(input, options) {
                 s13 = peg$currPos;
                 peg$silentFails++;
                 s14 = input.charAt(peg$currPos);
-                if (peg$r9.test(s14)) {
+                if (peg$r11.test(s14)) {
                   peg$currPos++;
                 } else {
                   s14 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e225); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e260); }
                 }
                 peg$silentFails--;
                 if (s14 === peg$FAILED) {
@@ -42592,7 +52013,7 @@ function peg$parse(input, options) {
                     peg$currPos++;
                   } else {
                     s14 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e24); }
                   }
                   if (s14 !== peg$FAILED) {
                     s13 = [s13, s14];
@@ -42611,11 +52032,11 @@ function peg$parse(input, options) {
                   s13 = peg$currPos;
                   peg$silentFails++;
                   s14 = input.charAt(peg$currPos);
-                  if (peg$r9.test(s14)) {
+                  if (peg$r11.test(s14)) {
                     peg$currPos++;
                   } else {
                     s14 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e225); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e260); }
                   }
                   peg$silentFails--;
                   if (s14 === peg$FAILED) {
@@ -42630,7 +52051,7 @@ function peg$parse(input, options) {
                       peg$currPos++;
                     } else {
                       s14 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e24); }
                     }
                     if (s14 !== peg$FAILED) {
                       s13 = [s13, s14];
@@ -42646,7 +52067,7 @@ function peg$parse(input, options) {
                 }
                 s10 = input.substring(s10, peg$currPos);
                 peg$savedPos = s0;
-                s0 = peg$f321(s10);
+                s0 = peg$f429(s10);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -42680,7 +52101,7 @@ function peg$parse(input, options) {
   function peg$parseCreateLiveViewStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14;
 
-    const key = peg$currPos * 466 + 198;
+    const key = peg$currPos * 508 + 240;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -42691,11 +52112,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c132) {
+    if (s1.toLowerCase() === peg$c142) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e138); }
+      if (peg$silentFails === 0) { peg$fail(peg$e151); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -42718,11 +52139,11 @@ function peg$parse(input, options) {
         s3 = peg$parse_();
         s4 = peg$currPos;
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c149) {
+        if (s5.toLowerCase() === peg$c193) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e155); }
+          if (peg$silentFails === 0) { peg$fail(peg$e202); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -42744,11 +52165,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 7);
-            if (s8.toLowerCase() === peg$c70) {
+            if (s8.toLowerCase() === peg$c74) {
               peg$currPos += (7);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e75); }
+              if (peg$silentFails === 0) { peg$fail(peg$e79); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -42791,11 +52212,11 @@ function peg$parse(input, options) {
           s4 = null;
         }
         s5 = input.substr(peg$currPos, 4);
-        if (s5.toLowerCase() === peg$c215) {
+        if (s5.toLowerCase() === peg$c248) {
           peg$currPos += (4);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e226); }
+          if (peg$silentFails === 0) { peg$fail(peg$e261); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -42817,11 +52238,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 4);
-            if (s8.toLowerCase() === peg$c112) {
+            if (s8.toLowerCase() === peg$c111) {
               peg$currPos += (4);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e118); }
+              if (peg$silentFails === 0) { peg$fail(peg$e117); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -42847,11 +52268,11 @@ function peg$parse(input, options) {
                 s13 = peg$currPos;
                 peg$silentFails++;
                 s14 = input.charAt(peg$currPos);
-                if (peg$r9.test(s14)) {
+                if (peg$r11.test(s14)) {
                   peg$currPos++;
                 } else {
                   s14 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e225); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e260); }
                 }
                 peg$silentFails--;
                 if (s14 === peg$FAILED) {
@@ -42866,7 +52287,7 @@ function peg$parse(input, options) {
                     peg$currPos++;
                   } else {
                     s14 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e24); }
                   }
                   if (s14 !== peg$FAILED) {
                     s13 = [s13, s14];
@@ -42885,11 +52306,11 @@ function peg$parse(input, options) {
                   s13 = peg$currPos;
                   peg$silentFails++;
                   s14 = input.charAt(peg$currPos);
-                  if (peg$r9.test(s14)) {
+                  if (peg$r11.test(s14)) {
                     peg$currPos++;
                   } else {
                     s14 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e225); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e260); }
                   }
                   peg$silentFails--;
                   if (s14 === peg$FAILED) {
@@ -42904,7 +52325,7 @@ function peg$parse(input, options) {
                       peg$currPos++;
                     } else {
                       s14 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e24); }
                     }
                     if (s14 !== peg$FAILED) {
                       s13 = [s13, s14];
@@ -42920,7 +52341,7 @@ function peg$parse(input, options) {
                 }
                 s10 = input.substring(s10, peg$currPos);
                 peg$savedPos = s0;
-                s0 = peg$f322(s10);
+                s0 = peg$f430(s10);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -42954,7 +52375,7 @@ function peg$parse(input, options) {
   function peg$parseCreateTableStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 199;
+    const key = peg$currPos * 508 + 241;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -42969,11 +52390,11 @@ function peg$parse(input, options) {
       s2 = peg$currPos;
       s3 = peg$parse_();
       s4 = input.substr(peg$currPos, 4);
-      if (s4.toLowerCase() === peg$c69) {
+      if (s4.toLowerCase() === peg$c73) {
         peg$currPos += (4);
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e74); }
+        if (peg$silentFails === 0) { peg$fail(peg$e78); }
       }
       if (s4 !== peg$FAILED) {
         s5 = peg$currPos;
@@ -43030,7 +52451,7 @@ function peg$parse(input, options) {
           s5 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f323(s1, s2, s4, s5);
+        s0 = peg$f431(s1, s2, s4, s5);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -43048,7 +52469,7 @@ function peg$parse(input, options) {
   function peg$parseCreateTableHeader() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18;
 
-    const key = peg$currPos * 466 + 200;
+    const key = peg$currPos * 508 + 242;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -43059,11 +52480,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c70) {
+    if (s1.toLowerCase() === peg$c74) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e75); }
+      if (peg$silentFails === 0) { peg$fail(peg$e79); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -43086,11 +52507,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 9);
-        if (s5.toLowerCase() === peg$c19) {
+        if (s5.toLowerCase() === peg$c22) {
           peg$currPos += (9);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e23); }
+          if (peg$silentFails === 0) { peg$fail(peg$e26); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -43125,11 +52546,11 @@ function peg$parse(input, options) {
         }
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 5);
-        if (s5.toLowerCase() === peg$c20) {
+        if (s5.toLowerCase() === peg$c23) {
           peg$currPos += (5);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e24); }
+          if (peg$silentFails === 0) { peg$fail(peg$e27); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -43166,7 +52587,7 @@ function peg$parse(input, options) {
                 s9 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f324(s3, s8, s9);
+              s0 = peg$f432(s3, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -43190,19 +52611,19 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 6);
-      if (s1.toLowerCase() === peg$c132) {
+      if (s1.toLowerCase() === peg$c142) {
         peg$currPos += (6);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e138); }
+        if (peg$silentFails === 0) { peg$fail(peg$e151); }
       }
       if (s1 === peg$FAILED) {
         s1 = input.substr(peg$currPos, 6);
-        if (s1.toLowerCase() === peg$c68) {
+        if (s1.toLowerCase() === peg$c72) {
           peg$currPos += (6);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e73); }
+          if (peg$silentFails === 0) { peg$fail(peg$e77); }
         }
       }
       if (s1 !== peg$FAILED) {
@@ -43226,11 +52647,11 @@ function peg$parse(input, options) {
           s3 = peg$currPos;
           s4 = peg$parse_();
           s5 = input.substr(peg$currPos, 2);
-          if (s5.toLowerCase() === peg$c149) {
+          if (s5.toLowerCase() === peg$c193) {
             peg$currPos += (2);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e155); }
+            if (peg$silentFails === 0) { peg$fail(peg$e202); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$currPos;
@@ -43252,11 +52673,11 @@ function peg$parse(input, options) {
             if (s6 !== peg$FAILED) {
               s7 = peg$parse_();
               s8 = input.substr(peg$currPos, 7);
-              if (s8.toLowerCase() === peg$c70) {
+              if (s8.toLowerCase() === peg$c74) {
                 peg$currPos += (7);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e75); }
+                if (peg$silentFails === 0) { peg$fail(peg$e79); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -43300,11 +52721,11 @@ function peg$parse(input, options) {
           s4 = peg$currPos;
           s5 = peg$parse_();
           s6 = input.substr(peg$currPos, 9);
-          if (s6.toLowerCase() === peg$c19) {
+          if (s6.toLowerCase() === peg$c22) {
             peg$currPos += (9);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e23); }
+            if (peg$silentFails === 0) { peg$fail(peg$e26); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$currPos;
@@ -43339,11 +52760,11 @@ function peg$parse(input, options) {
           }
           s5 = peg$parse_();
           s6 = input.substr(peg$currPos, 5);
-          if (s6.toLowerCase() === peg$c20) {
+          if (s6.toLowerCase() === peg$c23) {
             peg$currPos += (5);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e24); }
+            if (peg$silentFails === 0) { peg$fail(peg$e27); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$currPos;
@@ -43366,11 +52787,11 @@ function peg$parse(input, options) {
               s8 = peg$currPos;
               s9 = peg$parse_();
               s10 = input.substr(peg$currPos, 2);
-              if (s10.toLowerCase() === peg$c25) {
+              if (s10.toLowerCase() === peg$c29) {
                 peg$currPos += (2);
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                if (peg$silentFails === 0) { peg$fail(peg$e33); }
               }
               if (s10 !== peg$FAILED) {
                 s11 = peg$currPos;
@@ -43392,11 +52813,11 @@ function peg$parse(input, options) {
                 if (s11 !== peg$FAILED) {
                   s12 = peg$parse_();
                   s13 = input.substr(peg$currPos, 3);
-                  if (s13.toLowerCase() === peg$c26) {
+                  if (s13.toLowerCase() === peg$c30) {
                     peg$currPos += (3);
                   } else {
                     s13 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e34); }
                   }
                   if (s13 !== peg$FAILED) {
                     s14 = peg$currPos;
@@ -43418,11 +52839,11 @@ function peg$parse(input, options) {
                     if (s14 !== peg$FAILED) {
                       s15 = peg$parse_();
                       s16 = input.substr(peg$currPos, 6);
-                      if (s16.toLowerCase() === peg$c27) {
+                      if (s16.toLowerCase() === peg$c31) {
                         peg$currPos += (6);
                       } else {
                         s16 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e35); }
                       }
                       if (s16 !== peg$FAILED) {
                         s17 = peg$currPos;
@@ -43488,7 +52909,7 @@ function peg$parse(input, options) {
                   s11 = null;
                 }
                 peg$savedPos = s0;
-                s0 = peg$f325(s1, s3, s4, s8, s10, s11);
+                s0 = peg$f433(s1, s3, s4, s8, s10, s11);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -43519,7 +52940,7 @@ function peg$parse(input, options) {
   function peg$parseOnClusterClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 201;
+    const key = peg$currPos * 508 + 243;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -43530,11 +52951,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c103) {
+    if (s1.toLowerCase() === peg$c94) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e108); }
+      if (peg$silentFails === 0) { peg$fail(peg$e99); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -43556,11 +52977,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 7);
-        if (s4.toLowerCase() === peg$c170) {
+        if (s4.toLowerCase() === peg$c139) {
           peg$currPos += (7);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e176); }
+          if (peg$silentFails === 0) { peg$fail(peg$e148); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -43585,7 +53006,7 @@ function peg$parse(input, options) {
             s8 = peg$parseStringLiteral();
             if (s8 !== peg$FAILED) {
               peg$savedPos = s7;
-              s8 = peg$f326();
+              s8 = peg$f434();
             }
             s7 = s8;
             if (s7 === peg$FAILED) {
@@ -43593,7 +53014,7 @@ function peg$parse(input, options) {
             }
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f327(s7);
+              s0 = peg$f435(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -43623,7 +53044,7 @@ function peg$parse(input, options) {
   function peg$parseRefreshClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 202;
+    const key = peg$currPos * 508 + 244;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -43634,11 +53055,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c216) {
+    if (s1.toLowerCase() === peg$c249) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e227); }
+      if (peg$silentFails === 0) { peg$fail(peg$e262); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -43664,50 +53085,21 @@ function peg$parse(input, options) {
         s6 = peg$parse_();
         s7 = peg$currPos;
         peg$silentFails++;
-        s8 = peg$currPos;
-        s9 = input.substr(peg$currPos, 2);
-        if (s9.toLowerCase() === peg$c11) {
-          peg$currPos += (2);
-        } else {
-          s9 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e13); }
-        }
-        if (s9 !== peg$FAILED) {
-          s10 = peg$currPos;
-          peg$silentFails++;
-          s11 = input.charAt(peg$currPos);
-          if (peg$r0.test(s11)) {
-            peg$currPos++;
-          } else {
-            s11 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e2); }
-          }
-          peg$silentFails--;
-          if (s11 === peg$FAILED) {
-            s10 = undefined;
-          } else {
-            peg$currPos = s10;
-            s10 = peg$FAILED;
-          }
-          if (s10 !== peg$FAILED) {
-            s9 = [s9, s10];
-            s8 = s9;
-          } else {
-            peg$currPos = s8;
-            s8 = peg$FAILED;
-          }
+        if (input.charCodeAt(peg$currPos) === 59) {
+          s8 = peg$c0;
+          peg$currPos++;
         } else {
-          peg$currPos = s8;
           s8 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e0); }
         }
         if (s8 === peg$FAILED) {
           s8 = peg$currPos;
-          s9 = input.substr(peg$currPos, 6);
-          if (s9.toLowerCase() === peg$c217) {
-            peg$currPos += (6);
+          s9 = input.substr(peg$currPos, 2);
+          if (s9.toLowerCase() === peg$c11) {
+            peg$currPos += (2);
           } else {
             s9 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e228); }
+            if (peg$silentFails === 0) { peg$fail(peg$e13); }
           }
           if (s9 !== peg$FAILED) {
             s10 = peg$currPos;
@@ -43738,60 +53130,60 @@ function peg$parse(input, options) {
             s8 = peg$FAILED;
           }
           if (s8 === peg$FAILED) {
-            if (input.charCodeAt(peg$currPos) === 40) {
-              s8 = peg$c21;
-              peg$currPos++;
+            s8 = peg$currPos;
+            s9 = input.substr(peg$currPos, 6);
+            if (s9.toLowerCase() === peg$c250) {
+              peg$currPos += (6);
             } else {
+              s9 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e263); }
+            }
+            if (s9 !== peg$FAILED) {
+              s10 = peg$currPos;
+              peg$silentFails++;
+              s11 = input.charAt(peg$currPos);
+              if (peg$r0.test(s11)) {
+                peg$currPos++;
+              } else {
+                s11 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e2); }
+              }
+              peg$silentFails--;
+              if (s11 === peg$FAILED) {
+                s10 = undefined;
+              } else {
+                peg$currPos = s10;
+                s10 = peg$FAILED;
+              }
+              if (s10 !== peg$FAILED) {
+                s9 = [s9, s10];
+                s8 = s9;
+              } else {
+                peg$currPos = s8;
+                s8 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s8;
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
             }
             if (s8 === peg$FAILED) {
-              s8 = peg$parseKW_AS();
+              if (input.charCodeAt(peg$currPos) === 40) {
+                s8 = peg$c25;
+                peg$currPos++;
+              } else {
+                s8 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              }
               if (s8 === peg$FAILED) {
-                s8 = peg$currPos;
-                s9 = input.substr(peg$currPos, 5);
-                if (s9.toLowerCase() === peg$c104) {
-                  peg$currPos += (5);
-                } else {
-                  s9 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e109); }
-                }
-                if (s9 !== peg$FAILED) {
-                  s10 = peg$currPos;
-                  peg$silentFails++;
-                  s11 = input.charAt(peg$currPos);
-                  if (peg$r0.test(s11)) {
-                    peg$currPos++;
-                  } else {
-                    s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
-                  }
-                  peg$silentFails--;
-                  if (s11 === peg$FAILED) {
-                    s10 = undefined;
-                  } else {
-                    peg$currPos = s10;
-                    s10 = peg$FAILED;
-                  }
-                  if (s10 !== peg$FAILED) {
-                    s9 = [s9, s10];
-                    s8 = s9;
-                  } else {
-                    peg$currPos = s8;
-                    s8 = peg$FAILED;
-                  }
-                } else {
-                  peg$currPos = s8;
-                  s8 = peg$FAILED;
-                }
+                s8 = peg$parseKW_AS();
                 if (s8 === peg$FAILED) {
                   s8 = peg$currPos;
-                  s9 = input.substr(peg$currPos, 8);
-                  if (s9.toLowerCase() === peg$c151) {
-                    peg$currPos += (8);
+                  s9 = input.substr(peg$currPos, 5);
+                  if (s9.toLowerCase() === peg$c95) {
+                    peg$currPos += (5);
                   } else {
                     s9 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e157); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e100); }
                   }
                   if (s9 !== peg$FAILED) {
                     s10 = peg$currPos;
@@ -43823,12 +53215,12 @@ function peg$parse(input, options) {
                   }
                   if (s8 === peg$FAILED) {
                     s8 = peg$currPos;
-                    s9 = input.substr(peg$currPos, 5);
-                    if (s9.toLowerCase() === peg$c79) {
-                      peg$currPos += (5);
+                    s9 = input.substr(peg$currPos, 8);
+                    if (s9.toLowerCase() === peg$c195) {
+                      peg$currPos += (8);
                     } else {
                       s9 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e84); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e204); }
                     }
                     if (s9 !== peg$FAILED) {
                       s10 = peg$currPos;
@@ -43860,12 +53252,12 @@ function peg$parse(input, options) {
                     }
                     if (s8 === peg$FAILED) {
                       s8 = peg$currPos;
-                      s9 = input.substr(peg$currPos, 9);
-                      if (s9.toLowerCase() === peg$c66) {
-                        peg$currPos += (9);
+                      s9 = input.substr(peg$currPos, 5);
+                      if (s9.toLowerCase() === peg$c83) {
+                        peg$currPos += (5);
                       } else {
                         s9 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e71); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e88); }
                       }
                       if (s9 !== peg$FAILED) {
                         s10 = peg$currPos;
@@ -43897,12 +53289,12 @@ function peg$parse(input, options) {
                       }
                       if (s8 === peg$FAILED) {
                         s8 = peg$currPos;
-                        s9 = input.substr(peg$currPos, 7);
-                        if (s9.toLowerCase() === peg$c48) {
-                          peg$currPos += (7);
+                        s9 = input.substr(peg$currPos, 9);
+                        if (s9.toLowerCase() === peg$c70) {
+                          peg$currPos += (9);
                         } else {
                           s9 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e53); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e75); }
                         }
                         if (s9 !== peg$FAILED) {
                           s10 = peg$currPos;
@@ -43934,12 +53326,12 @@ function peg$parse(input, options) {
                         }
                         if (s8 === peg$FAILED) {
                           s8 = peg$currPos;
-                          s9 = input.substr(peg$currPos, 6);
-                          if (s9.toLowerCase() === peg$c81) {
-                            peg$currPos += (6);
+                          s9 = input.substr(peg$currPos, 7);
+                          if (s9.toLowerCase() === peg$c52) {
+                            peg$currPos += (7);
                           } else {
                             s9 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e86); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e57); }
                           }
                           if (s9 !== peg$FAILED) {
                             s10 = peg$currPos;
@@ -43971,12 +53363,12 @@ function peg$parse(input, options) {
                           }
                           if (s8 === peg$FAILED) {
                             s8 = peg$currPos;
-                            s9 = input.substr(peg$currPos, 3);
-                            if (s9.toLowerCase() === peg$c41) {
-                              peg$currPos += (3);
+                            s9 = input.substr(peg$currPos, 6);
+                            if (s9.toLowerCase() === peg$c85) {
+                              peg$currPos += (6);
                             } else {
                               s9 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e45); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e90); }
                             }
                             if (s9 !== peg$FAILED) {
                               s10 = peg$currPos;
@@ -44007,43 +53399,119 @@ function peg$parse(input, options) {
                               s8 = peg$FAILED;
                             }
                             if (s8 === peg$FAILED) {
-                              s8 = peg$parseKW_SETTINGS();
-                              if (s8 === peg$FAILED) {
-                                s8 = peg$currPos;
-                                s9 = input.substr(peg$currPos, 7);
-                                if (s9.toLowerCase() === peg$c39) {
-                                  peg$currPos += (7);
+                              s8 = peg$currPos;
+                              s9 = input.substr(peg$currPos, 3);
+                              if (s9.toLowerCase() === peg$c45) {
+                                peg$currPos += (3);
+                              } else {
+                                s9 = peg$FAILED;
+                                if (peg$silentFails === 0) { peg$fail(peg$e49); }
+                              }
+                              if (s9 !== peg$FAILED) {
+                                s10 = peg$currPos;
+                                peg$silentFails++;
+                                s11 = input.charAt(peg$currPos);
+                                if (peg$r0.test(s11)) {
+                                  peg$currPos++;
                                 } else {
-                                  s9 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e43); }
+                                  s11 = peg$FAILED;
+                                  if (peg$silentFails === 0) { peg$fail(peg$e2); }
                                 }
-                                if (s9 !== peg$FAILED) {
-                                  s10 = peg$currPos;
-                                  peg$silentFails++;
-                                  s11 = input.charAt(peg$currPos);
-                                  if (peg$r0.test(s11)) {
-                                    peg$currPos++;
-                                  } else {
-                                    s11 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
-                                  }
-                                  peg$silentFails--;
-                                  if (s11 === peg$FAILED) {
-                                    s10 = undefined;
+                                peg$silentFails--;
+                                if (s11 === peg$FAILED) {
+                                  s10 = undefined;
+                                } else {
+                                  peg$currPos = s10;
+                                  s10 = peg$FAILED;
+                                }
+                                if (s10 !== peg$FAILED) {
+                                  s9 = [s9, s10];
+                                  s8 = s9;
+                                } else {
+                                  peg$currPos = s8;
+                                  s8 = peg$FAILED;
+                                }
+                              } else {
+                                peg$currPos = s8;
+                                s8 = peg$FAILED;
+                              }
+                              if (s8 === peg$FAILED) {
+                                s8 = peg$parseKW_SETTINGS();
+                                if (s8 === peg$FAILED) {
+                                  s8 = peg$currPos;
+                                  s9 = input.substr(peg$currPos, 7);
+                                  if (s9.toLowerCase() === peg$c43) {
+                                    peg$currPos += (7);
                                   } else {
-                                    peg$currPos = s10;
-                                    s10 = peg$FAILED;
+                                    s9 = peg$FAILED;
+                                    if (peg$silentFails === 0) { peg$fail(peg$e47); }
                                   }
-                                  if (s10 !== peg$FAILED) {
-                                    s9 = [s9, s10];
-                                    s8 = s9;
+                                  if (s9 !== peg$FAILED) {
+                                    s10 = peg$currPos;
+                                    peg$silentFails++;
+                                    s11 = input.charAt(peg$currPos);
+                                    if (peg$r0.test(s11)) {
+                                      peg$currPos++;
+                                    } else {
+                                      s11 = peg$FAILED;
+                                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                                    }
+                                    peg$silentFails--;
+                                    if (s11 === peg$FAILED) {
+                                      s10 = undefined;
+                                    } else {
+                                      peg$currPos = s10;
+                                      s10 = peg$FAILED;
+                                    }
+                                    if (s10 !== peg$FAILED) {
+                                      s9 = [s9, s10];
+                                      s8 = s9;
+                                    } else {
+                                      peg$currPos = s8;
+                                      s8 = peg$FAILED;
+                                    }
                                   } else {
                                     peg$currPos = s8;
                                     s8 = peg$FAILED;
                                   }
-                                } else {
-                                  peg$currPos = s8;
-                                  s8 = peg$FAILED;
+                                  if (s8 === peg$FAILED) {
+                                    s8 = peg$currPos;
+                                    s9 = input.substr(peg$currPos, 6);
+                                    if (s9.toLowerCase() === peg$c177) {
+                                      peg$currPos += (6);
+                                    } else {
+                                      s9 = peg$FAILED;
+                                      if (peg$silentFails === 0) { peg$fail(peg$e186); }
+                                    }
+                                    if (s9 !== peg$FAILED) {
+                                      s10 = peg$currPos;
+                                      peg$silentFails++;
+                                      s11 = input.charAt(peg$currPos);
+                                      if (peg$r0.test(s11)) {
+                                        peg$currPos++;
+                                      } else {
+                                        s11 = peg$FAILED;
+                                        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                                      }
+                                      peg$silentFails--;
+                                      if (s11 === peg$FAILED) {
+                                        s10 = undefined;
+                                      } else {
+                                        peg$currPos = s10;
+                                        s10 = peg$FAILED;
+                                      }
+                                      if (s10 !== peg$FAILED) {
+                                        s9 = [s9, s10];
+                                        s8 = s9;
+                                      } else {
+                                        peg$currPos = s8;
+                                        s8 = peg$FAILED;
+                                      }
+                                    } else {
+                                      peg$currPos = s8;
+                                      s8 = peg$FAILED;
+                                    }
+                                  }
                                 }
                               }
                             }
@@ -44070,7 +53538,7 @@ function peg$parse(input, options) {
             peg$currPos++;
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e21); }
+            if (peg$silentFails === 0) { peg$fail(peg$e24); }
           }
           if (s8 !== peg$FAILED) {
             s6 = [s6, s7, s8];
@@ -44090,50 +53558,21 @@ function peg$parse(input, options) {
             s6 = peg$parse_();
             s7 = peg$currPos;
             peg$silentFails++;
-            s8 = peg$currPos;
-            s9 = input.substr(peg$currPos, 2);
-            if (s9.toLowerCase() === peg$c11) {
-              peg$currPos += (2);
-            } else {
-              s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e13); }
-            }
-            if (s9 !== peg$FAILED) {
-              s10 = peg$currPos;
-              peg$silentFails++;
-              s11 = input.charAt(peg$currPos);
-              if (peg$r0.test(s11)) {
-                peg$currPos++;
-              } else {
-                s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e2); }
-              }
-              peg$silentFails--;
-              if (s11 === peg$FAILED) {
-                s10 = undefined;
-              } else {
-                peg$currPos = s10;
-                s10 = peg$FAILED;
-              }
-              if (s10 !== peg$FAILED) {
-                s9 = [s9, s10];
-                s8 = s9;
-              } else {
-                peg$currPos = s8;
-                s8 = peg$FAILED;
-              }
+            if (input.charCodeAt(peg$currPos) === 59) {
+              s8 = peg$c0;
+              peg$currPos++;
             } else {
-              peg$currPos = s8;
               s8 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e0); }
             }
             if (s8 === peg$FAILED) {
               s8 = peg$currPos;
-              s9 = input.substr(peg$currPos, 6);
-              if (s9.toLowerCase() === peg$c217) {
-                peg$currPos += (6);
+              s9 = input.substr(peg$currPos, 2);
+              if (s9.toLowerCase() === peg$c11) {
+                peg$currPos += (2);
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e228); }
+                if (peg$silentFails === 0) { peg$fail(peg$e13); }
               }
               if (s9 !== peg$FAILED) {
                 s10 = peg$currPos;
@@ -44164,60 +53603,60 @@ function peg$parse(input, options) {
                 s8 = peg$FAILED;
               }
               if (s8 === peg$FAILED) {
-                if (input.charCodeAt(peg$currPos) === 40) {
-                  s8 = peg$c21;
-                  peg$currPos++;
+                s8 = peg$currPos;
+                s9 = input.substr(peg$currPos, 6);
+                if (s9.toLowerCase() === peg$c250) {
+                  peg$currPos += (6);
                 } else {
+                  s9 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e263); }
+                }
+                if (s9 !== peg$FAILED) {
+                  s10 = peg$currPos;
+                  peg$silentFails++;
+                  s11 = input.charAt(peg$currPos);
+                  if (peg$r0.test(s11)) {
+                    peg$currPos++;
+                  } else {
+                    s11 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                  }
+                  peg$silentFails--;
+                  if (s11 === peg$FAILED) {
+                    s10 = undefined;
+                  } else {
+                    peg$currPos = s10;
+                    s10 = peg$FAILED;
+                  }
+                  if (s10 !== peg$FAILED) {
+                    s9 = [s9, s10];
+                    s8 = s9;
+                  } else {
+                    peg$currPos = s8;
+                    s8 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s8;
                   s8 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e25); }
                 }
                 if (s8 === peg$FAILED) {
-                  s8 = peg$parseKW_AS();
+                  if (input.charCodeAt(peg$currPos) === 40) {
+                    s8 = peg$c25;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                  }
                   if (s8 === peg$FAILED) {
-                    s8 = peg$currPos;
-                    s9 = input.substr(peg$currPos, 5);
-                    if (s9.toLowerCase() === peg$c104) {
-                      peg$currPos += (5);
-                    } else {
-                      s9 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e109); }
-                    }
-                    if (s9 !== peg$FAILED) {
-                      s10 = peg$currPos;
-                      peg$silentFails++;
-                      s11 = input.charAt(peg$currPos);
-                      if (peg$r0.test(s11)) {
-                        peg$currPos++;
-                      } else {
-                        s11 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e2); }
-                      }
-                      peg$silentFails--;
-                      if (s11 === peg$FAILED) {
-                        s10 = undefined;
-                      } else {
-                        peg$currPos = s10;
-                        s10 = peg$FAILED;
-                      }
-                      if (s10 !== peg$FAILED) {
-                        s9 = [s9, s10];
-                        s8 = s9;
-                      } else {
-                        peg$currPos = s8;
-                        s8 = peg$FAILED;
-                      }
-                    } else {
-                      peg$currPos = s8;
-                      s8 = peg$FAILED;
-                    }
+                    s8 = peg$parseKW_AS();
                     if (s8 === peg$FAILED) {
                       s8 = peg$currPos;
-                      s9 = input.substr(peg$currPos, 8);
-                      if (s9.toLowerCase() === peg$c151) {
-                        peg$currPos += (8);
+                      s9 = input.substr(peg$currPos, 5);
+                      if (s9.toLowerCase() === peg$c95) {
+                        peg$currPos += (5);
                       } else {
                         s9 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e157); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e100); }
                       }
                       if (s9 !== peg$FAILED) {
                         s10 = peg$currPos;
@@ -44249,12 +53688,12 @@ function peg$parse(input, options) {
                       }
                       if (s8 === peg$FAILED) {
                         s8 = peg$currPos;
-                        s9 = input.substr(peg$currPos, 5);
-                        if (s9.toLowerCase() === peg$c79) {
-                          peg$currPos += (5);
+                        s9 = input.substr(peg$currPos, 8);
+                        if (s9.toLowerCase() === peg$c195) {
+                          peg$currPos += (8);
                         } else {
                           s9 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e84); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e204); }
                         }
                         if (s9 !== peg$FAILED) {
                           s10 = peg$currPos;
@@ -44286,12 +53725,12 @@ function peg$parse(input, options) {
                         }
                         if (s8 === peg$FAILED) {
                           s8 = peg$currPos;
-                          s9 = input.substr(peg$currPos, 9);
-                          if (s9.toLowerCase() === peg$c66) {
-                            peg$currPos += (9);
+                          s9 = input.substr(peg$currPos, 5);
+                          if (s9.toLowerCase() === peg$c83) {
+                            peg$currPos += (5);
                           } else {
                             s9 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e71); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e88); }
                           }
                           if (s9 !== peg$FAILED) {
                             s10 = peg$currPos;
@@ -44323,12 +53762,12 @@ function peg$parse(input, options) {
                           }
                           if (s8 === peg$FAILED) {
                             s8 = peg$currPos;
-                            s9 = input.substr(peg$currPos, 7);
-                            if (s9.toLowerCase() === peg$c48) {
-                              peg$currPos += (7);
+                            s9 = input.substr(peg$currPos, 9);
+                            if (s9.toLowerCase() === peg$c70) {
+                              peg$currPos += (9);
                             } else {
                               s9 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e53); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e75); }
                             }
                             if (s9 !== peg$FAILED) {
                               s10 = peg$currPos;
@@ -44360,12 +53799,12 @@ function peg$parse(input, options) {
                             }
                             if (s8 === peg$FAILED) {
                               s8 = peg$currPos;
-                              s9 = input.substr(peg$currPos, 6);
-                              if (s9.toLowerCase() === peg$c81) {
-                                peg$currPos += (6);
+                              s9 = input.substr(peg$currPos, 7);
+                              if (s9.toLowerCase() === peg$c52) {
+                                peg$currPos += (7);
                               } else {
                                 s9 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e86); }
+                                if (peg$silentFails === 0) { peg$fail(peg$e57); }
                               }
                               if (s9 !== peg$FAILED) {
                                 s10 = peg$currPos;
@@ -44397,12 +53836,12 @@ function peg$parse(input, options) {
                               }
                               if (s8 === peg$FAILED) {
                                 s8 = peg$currPos;
-                                s9 = input.substr(peg$currPos, 3);
-                                if (s9.toLowerCase() === peg$c41) {
-                                  peg$currPos += (3);
+                                s9 = input.substr(peg$currPos, 6);
+                                if (s9.toLowerCase() === peg$c85) {
+                                  peg$currPos += (6);
                                 } else {
                                   s9 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e45); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e90); }
                                 }
                                 if (s9 !== peg$FAILED) {
                                   s10 = peg$currPos;
@@ -44433,43 +53872,119 @@ function peg$parse(input, options) {
                                   s8 = peg$FAILED;
                                 }
                                 if (s8 === peg$FAILED) {
-                                  s8 = peg$parseKW_SETTINGS();
-                                  if (s8 === peg$FAILED) {
-                                    s8 = peg$currPos;
-                                    s9 = input.substr(peg$currPos, 7);
-                                    if (s9.toLowerCase() === peg$c39) {
-                                      peg$currPos += (7);
+                                  s8 = peg$currPos;
+                                  s9 = input.substr(peg$currPos, 3);
+                                  if (s9.toLowerCase() === peg$c45) {
+                                    peg$currPos += (3);
+                                  } else {
+                                    s9 = peg$FAILED;
+                                    if (peg$silentFails === 0) { peg$fail(peg$e49); }
+                                  }
+                                  if (s9 !== peg$FAILED) {
+                                    s10 = peg$currPos;
+                                    peg$silentFails++;
+                                    s11 = input.charAt(peg$currPos);
+                                    if (peg$r0.test(s11)) {
+                                      peg$currPos++;
                                     } else {
-                                      s9 = peg$FAILED;
-                                      if (peg$silentFails === 0) { peg$fail(peg$e43); }
+                                      s11 = peg$FAILED;
+                                      if (peg$silentFails === 0) { peg$fail(peg$e2); }
                                     }
-                                    if (s9 !== peg$FAILED) {
-                                      s10 = peg$currPos;
-                                      peg$silentFails++;
-                                      s11 = input.charAt(peg$currPos);
-                                      if (peg$r0.test(s11)) {
-                                        peg$currPos++;
-                                      } else {
-                                        s11 = peg$FAILED;
-                                        if (peg$silentFails === 0) { peg$fail(peg$e2); }
-                                      }
-                                      peg$silentFails--;
-                                      if (s11 === peg$FAILED) {
-                                        s10 = undefined;
+                                    peg$silentFails--;
+                                    if (s11 === peg$FAILED) {
+                                      s10 = undefined;
+                                    } else {
+                                      peg$currPos = s10;
+                                      s10 = peg$FAILED;
+                                    }
+                                    if (s10 !== peg$FAILED) {
+                                      s9 = [s9, s10];
+                                      s8 = s9;
+                                    } else {
+                                      peg$currPos = s8;
+                                      s8 = peg$FAILED;
+                                    }
+                                  } else {
+                                    peg$currPos = s8;
+                                    s8 = peg$FAILED;
+                                  }
+                                  if (s8 === peg$FAILED) {
+                                    s8 = peg$parseKW_SETTINGS();
+                                    if (s8 === peg$FAILED) {
+                                      s8 = peg$currPos;
+                                      s9 = input.substr(peg$currPos, 7);
+                                      if (s9.toLowerCase() === peg$c43) {
+                                        peg$currPos += (7);
                                       } else {
-                                        peg$currPos = s10;
-                                        s10 = peg$FAILED;
+                                        s9 = peg$FAILED;
+                                        if (peg$silentFails === 0) { peg$fail(peg$e47); }
                                       }
-                                      if (s10 !== peg$FAILED) {
-                                        s9 = [s9, s10];
-                                        s8 = s9;
+                                      if (s9 !== peg$FAILED) {
+                                        s10 = peg$currPos;
+                                        peg$silentFails++;
+                                        s11 = input.charAt(peg$currPos);
+                                        if (peg$r0.test(s11)) {
+                                          peg$currPos++;
+                                        } else {
+                                          s11 = peg$FAILED;
+                                          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                                        }
+                                        peg$silentFails--;
+                                        if (s11 === peg$FAILED) {
+                                          s10 = undefined;
+                                        } else {
+                                          peg$currPos = s10;
+                                          s10 = peg$FAILED;
+                                        }
+                                        if (s10 !== peg$FAILED) {
+                                          s9 = [s9, s10];
+                                          s8 = s9;
+                                        } else {
+                                          peg$currPos = s8;
+                                          s8 = peg$FAILED;
+                                        }
                                       } else {
                                         peg$currPos = s8;
                                         s8 = peg$FAILED;
                                       }
-                                    } else {
-                                      peg$currPos = s8;
-                                      s8 = peg$FAILED;
+                                      if (s8 === peg$FAILED) {
+                                        s8 = peg$currPos;
+                                        s9 = input.substr(peg$currPos, 6);
+                                        if (s9.toLowerCase() === peg$c177) {
+                                          peg$currPos += (6);
+                                        } else {
+                                          s9 = peg$FAILED;
+                                          if (peg$silentFails === 0) { peg$fail(peg$e186); }
+                                        }
+                                        if (s9 !== peg$FAILED) {
+                                          s10 = peg$currPos;
+                                          peg$silentFails++;
+                                          s11 = input.charAt(peg$currPos);
+                                          if (peg$r0.test(s11)) {
+                                            peg$currPos++;
+                                          } else {
+                                            s11 = peg$FAILED;
+                                            if (peg$silentFails === 0) { peg$fail(peg$e2); }
+                                          }
+                                          peg$silentFails--;
+                                          if (s11 === peg$FAILED) {
+                                            s10 = undefined;
+                                          } else {
+                                            peg$currPos = s10;
+                                            s10 = peg$FAILED;
+                                          }
+                                          if (s10 !== peg$FAILED) {
+                                            s9 = [s9, s10];
+                                            s8 = s9;
+                                          } else {
+                                            peg$currPos = s8;
+                                            s8 = peg$FAILED;
+                                          }
+                                        } else {
+                                          peg$currPos = s8;
+                                          s8 = peg$FAILED;
+                                        }
+                                      }
                                     }
                                   }
                                 }
@@ -44496,7 +54011,7 @@ function peg$parse(input, options) {
                 peg$currPos++;
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                if (peg$silentFails === 0) { peg$fail(peg$e24); }
               }
               if (s8 !== peg$FAILED) {
                 s6 = [s6, s7, s8];
@@ -44520,7 +54035,7 @@ function peg$parse(input, options) {
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f328(s3);
+          s0 = peg$f436(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -44542,7 +54057,7 @@ function peg$parse(input, options) {
   function peg$parseCreateTableBody() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 203;
+    const key = peg$currPos * 508 + 245;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -44553,11 +54068,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c218) {
+    if (s1.toLowerCase() === peg$c251) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e229); }
+      if (peg$silentFails === 0) { peg$fail(peg$e264); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -44621,7 +54136,7 @@ function peg$parse(input, options) {
               }
               s9 = peg$parseCreateTableClauses();
               peg$savedPos = s0;
-              s0 = peg$f329(s7, s8, s9);
+              s0 = peg$f437(s7, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -44645,11 +54160,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c143) {
+      if (s1.toLowerCase() === peg$c104) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e149); }
+        if (peg$silentFails === 0) { peg$fail(peg$e110); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -44676,7 +54191,7 @@ function peg$parse(input, options) {
             s6 = peg$parseCreateTableBody();
             if (s6 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f330(s6);
+              s0 = peg$f438(s6);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -44722,7 +54237,7 @@ function peg$parse(input, options) {
               s5 = null;
             }
             peg$savedPos = s0;
-            s0 = peg$f331(s1, s3, s4, s5);
+            s0 = peg$f439(s1, s3, s4, s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -44767,11 +54282,11 @@ function peg$parse(input, options) {
                 if (s7 !== peg$FAILED) {
                   s8 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 40) {
-                    s9 = peg$c21;
+                    s9 = peg$c25;
                     peg$currPos++;
                   } else {
                     s9 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e29); }
                   }
                   if (s9 !== peg$FAILED) {
                     s10 = peg$parse_();
@@ -44781,15 +54296,15 @@ function peg$parse(input, options) {
                     }
                     s12 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 41) {
-                      s13 = peg$c22;
+                      s13 = peg$c26;
                       peg$currPos++;
                     } else {
                       s13 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e30); }
                     }
                     if (s13 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f332(s1, s2, s7, s11);
+                      s0 = peg$f440(s1, s2, s7, s11);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -44822,11 +54337,11 @@ function peg$parse(input, options) {
               s3 = peg$currPos;
               s4 = peg$parse_();
               s5 = input.substr(peg$currPos, 5);
-              if (s5.toLowerCase() === peg$c104) {
+              if (s5.toLowerCase() === peg$c95) {
                 peg$currPos += (5);
               } else {
                 s5 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e109); }
+                if (peg$silentFails === 0) { peg$fail(peg$e100); }
               }
               if (s5 !== peg$FAILED) {
                 s6 = peg$currPos;
@@ -44871,11 +54386,11 @@ function peg$parse(input, options) {
                   s9 = peg$parseKW_WITH();
                   if (s9 === peg$FAILED) {
                     if (input.charCodeAt(peg$currPos) === 40) {
-                      s9 = peg$c21;
+                      s9 = peg$c25;
                       peg$currPos++;
                     } else {
                       s9 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e29); }
                     }
                   }
                 }
@@ -44907,7 +54422,7 @@ function peg$parse(input, options) {
                 s4 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f333(s1, s2, s3, s4);
+              s0 = peg$f441(s1, s2, s3, s4);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -44920,11 +54435,11 @@ function peg$parse(input, options) {
                 s3 = peg$currPos;
                 s4 = peg$parse_();
                 s5 = input.substr(peg$currPos, 5);
-                if (s5.toLowerCase() === peg$c104) {
+                if (s5.toLowerCase() === peg$c95) {
                   peg$currPos += (5);
                 } else {
                   s5 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e109); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e100); }
                 }
                 if (s5 !== peg$FAILED) {
                   s6 = peg$currPos;
@@ -44964,7 +54479,7 @@ function peg$parse(input, options) {
                   s7 = peg$parseUnionQuery();
                   if (s7 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f334(s1, s2, s3, s7);
+                    s0 = peg$f442(s1, s2, s3, s7);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -45012,7 +54527,7 @@ function peg$parse(input, options) {
                       s7 = peg$parseTableRef();
                       if (s7 !== peg$FAILED) {
                         peg$savedPos = s0;
-                        s0 = peg$f335(s1, s2, s7);
+                        s0 = peg$f443(s1, s2, s7);
                       } else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
@@ -45035,7 +54550,7 @@ function peg$parse(input, options) {
                   if (s1 !== peg$FAILED) {
                     s2 = peg$parseCreateTableClauses();
                     peg$savedPos = s0;
-                    s0 = peg$f336(s1, s2);
+                    s0 = peg$f444(s1, s2);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -45045,43 +54560,43 @@ function peg$parse(input, options) {
                     s1 = peg$currPos;
                     peg$silentFails++;
                     s2 = input.substr(peg$currPos, 5);
-                    if (s2.toLowerCase() === peg$c79) {
+                    if (s2.toLowerCase() === peg$c83) {
                       peg$currPos += (5);
                     } else {
                       s2 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e84); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e88); }
                     }
                     if (s2 === peg$FAILED) {
                       s2 = input.substr(peg$currPos, 9);
-                      if (s2.toLowerCase() === peg$c66) {
+                      if (s2.toLowerCase() === peg$c70) {
                         peg$currPos += (9);
                       } else {
                         s2 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e71); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e75); }
                       }
                       if (s2 === peg$FAILED) {
                         s2 = input.substr(peg$currPos, 7);
-                        if (s2.toLowerCase() === peg$c48) {
+                        if (s2.toLowerCase() === peg$c52) {
                           peg$currPos += (7);
                         } else {
                           s2 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e53); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e57); }
                         }
                         if (s2 === peg$FAILED) {
                           s2 = input.substr(peg$currPos, 6);
-                          if (s2.toLowerCase() === peg$c81) {
+                          if (s2.toLowerCase() === peg$c85) {
                             peg$currPos += (6);
                           } else {
                             s2 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e86); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e90); }
                           }
                           if (s2 === peg$FAILED) {
                             s2 = input.substr(peg$currPos, 3);
-                            if (s2.toLowerCase() === peg$c41) {
+                            if (s2.toLowerCase() === peg$c45) {
                               peg$currPos += (3);
                             } else {
                               s2 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e45); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e49); }
                             }
                           }
                         }
@@ -45103,7 +54618,7 @@ function peg$parse(input, options) {
                         s6 = peg$parseUnionQuery();
                         if (s6 !== peg$FAILED) {
                           peg$savedPos = s0;
-                          s0 = peg$f337(s2, s6);
+                          s0 = peg$f445(s2, s6);
                         } else {
                           peg$currPos = s0;
                           s0 = peg$FAILED;
@@ -45119,11 +54634,11 @@ function peg$parse(input, options) {
                     if (s0 === peg$FAILED) {
                       s0 = peg$currPos;
                       s1 = input.substr(peg$currPos, 5);
-                      if (s1.toLowerCase() === peg$c104) {
+                      if (s1.toLowerCase() === peg$c95) {
                         peg$currPos += (5);
                       } else {
                         s1 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e109); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e100); }
                       }
                       if (s1 !== peg$FAILED) {
                         s2 = peg$currPos;
@@ -45177,11 +54692,11 @@ function peg$parse(input, options) {
                                 s8 = peg$parseKW_WITH();
                                 if (s8 === peg$FAILED) {
                                   if (input.charCodeAt(peg$currPos) === 40) {
-                                    s8 = peg$c21;
+                                    s8 = peg$c25;
                                     peg$currPos++;
                                   } else {
                                     s8 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                                    if (peg$silentFails === 0) { peg$fail(peg$e29); }
                                   }
                                 }
                               }
@@ -45196,7 +54711,7 @@ function peg$parse(input, options) {
                                 s8 = peg$parseTableRef();
                                 if (s8 !== peg$FAILED) {
                                   peg$savedPos = s0;
-                                  s0 = peg$f338(s8);
+                                  s0 = peg$f446(s8);
                                 } else {
                                   peg$currPos = s0;
                                   s0 = peg$FAILED;
@@ -45224,11 +54739,11 @@ function peg$parse(input, options) {
                       if (s0 === peg$FAILED) {
                         s0 = peg$currPos;
                         s1 = input.substr(peg$currPos, 5);
-                        if (s1.toLowerCase() === peg$c104) {
+                        if (s1.toLowerCase() === peg$c95) {
                           peg$currPos += (5);
                         } else {
                           s1 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e109); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e100); }
                         }
                         if (s1 !== peg$FAILED) {
                           s2 = peg$currPos;
@@ -45255,7 +54770,7 @@ function peg$parse(input, options) {
                               s6 = peg$parseUnionQuery();
                               if (s6 !== peg$FAILED) {
                                 peg$savedPos = s0;
-                                s0 = peg$f339(s6);
+                                s0 = peg$f447(s6);
                               } else {
                                 peg$currPos = s0;
                                 s0 = peg$FAILED;
@@ -45284,11 +54799,11 @@ function peg$parse(input, options) {
                               s4 = peg$parseKW_WITH();
                               if (s4 === peg$FAILED) {
                                 if (input.charCodeAt(peg$currPos) === 40) {
-                                  s4 = peg$c21;
+                                  s4 = peg$c25;
                                   peg$currPos++;
                                 } else {
                                   s4 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e29); }
                                 }
                               }
                             }
@@ -45303,7 +54818,7 @@ function peg$parse(input, options) {
                               s4 = peg$parseUnionQuery();
                               if (s4 !== peg$FAILED) {
                                 peg$savedPos = s0;
-                                s0 = peg$f340(s4);
+                                s0 = peg$f448(s4);
                               } else {
                                 peg$currPos = s0;
                                 s0 = peg$FAILED;
@@ -45348,11 +54863,11 @@ function peg$parse(input, options) {
                                 if (s4 !== peg$FAILED) {
                                   s5 = peg$parse_();
                                   if (input.charCodeAt(peg$currPos) === 40) {
-                                    s6 = peg$c21;
+                                    s6 = peg$c25;
                                     peg$currPos++;
                                   } else {
                                     s6 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                                    if (peg$silentFails === 0) { peg$fail(peg$e29); }
                                   }
                                   if (s6 !== peg$FAILED) {
                                     s7 = peg$parse_();
@@ -45362,15 +54877,15 @@ function peg$parse(input, options) {
                                     }
                                     s9 = peg$parse_();
                                     if (input.charCodeAt(peg$currPos) === 41) {
-                                      s10 = peg$c22;
+                                      s10 = peg$c26;
                                       peg$currPos++;
                                     } else {
                                       s10 = peg$FAILED;
-                                      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                                      if (peg$silentFails === 0) { peg$fail(peg$e30); }
                                     }
                                     if (s10 !== peg$FAILED) {
                                       peg$savedPos = s0;
-                                      s0 = peg$f341(s4, s8);
+                                      s0 = peg$f449(s4, s8);
                                     } else {
                                       peg$currPos = s0;
                                       s0 = peg$FAILED;
@@ -45436,7 +54951,7 @@ function peg$parse(input, options) {
                                     }
                                     s6 = peg$parseCreateTableClauses();
                                     peg$savedPos = s0;
-                                    s0 = peg$f342(s4, s5, s6);
+                                    s0 = peg$f450(s4, s5, s6);
                                   } else {
                                     peg$currPos = s0;
                                     s0 = peg$FAILED;
@@ -45471,7 +54986,7 @@ function peg$parse(input, options) {
   function peg$parseCreateTableSchema() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 204;
+    const key = peg$currPos * 508 + 246;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -45482,11 +54997,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
@@ -45494,15 +55009,15 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s5 = peg$c22;
+          s5 = peg$c26;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f343(s3);
+          s0 = peg$f451(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -45524,7 +55039,7 @@ function peg$parse(input, options) {
   function peg$parseTableElementList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 205;
+    const key = peg$currPos * 508 + 247;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -45540,11 +55055,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -45565,11 +55080,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -45589,11 +55104,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s4 = [s4, s5];
@@ -45606,7 +55121,7 @@ function peg$parse(input, options) {
         s3 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f344(s1, s2, s3);
+      s0 = peg$f452(s1, s2, s3);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -45620,7 +55135,7 @@ function peg$parse(input, options) {
   function peg$parseTableElement() {
     let s0;
 
-    const key = peg$currPos * 466 + 206;
+    const key = peg$currPos * 508 + 248;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -45657,7 +55172,7 @@ function peg$parse(input, options) {
   function peg$parseProjectionIndexElement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14;
 
-    const key = peg$currPos * 466 + 207;
+    const key = peg$currPos * 508 + 249;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -45668,11 +55183,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 10);
-    if (s1.toLowerCase() === peg$c58) {
+    if (s1.toLowerCase() === peg$c62) {
       peg$currPos += (10);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e63); }
+      if (peg$silentFails === 0) { peg$fail(peg$e67); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -45697,11 +55212,11 @@ function peg$parse(input, options) {
         if (s4 !== peg$FAILED) {
           s5 = peg$parse_();
           s6 = input.substr(peg$currPos, 5);
-          if (s6.toLowerCase() === peg$c54) {
+          if (s6.toLowerCase() === peg$c58) {
             peg$currPos += (5);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e59); }
+            if (peg$silentFails === 0) { peg$fail(peg$e63); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$currPos;
@@ -45726,11 +55241,11 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 s11 = input.substr(peg$currPos, 4);
-                if (s11.toLowerCase() === peg$c33) {
+                if (s11.toLowerCase() === peg$c37) {
                   peg$currPos += (4);
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e37); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e41); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$currPos;
@@ -45754,7 +55269,7 @@ function peg$parse(input, options) {
                     s14 = peg$parseIndexTypeSpec();
                     if (s14 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f345(s4, s9, s14);
+                      s0 = peg$f453(s4, s9, s14);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -45800,7 +55315,7 @@ function peg$parse(input, options) {
   function peg$parseColumnElement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;
 
-    const key = peg$currPos * 466 + 208;
+    const key = peg$currPos * 508 + 250;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -45855,11 +55370,11 @@ function peg$parse(input, options) {
       if (s5 === peg$FAILED) {
         s5 = peg$currPos;
         s6 = input.substr(peg$currPos, 12);
-        if (s6.toLowerCase() === peg$c36) {
+        if (s6.toLowerCase() === peg$c40) {
           peg$currPos += (12);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e40); }
+          if (peg$silentFails === 0) { peg$fail(peg$e44); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -45892,11 +55407,11 @@ function peg$parse(input, options) {
         if (s5 === peg$FAILED) {
           s5 = peg$currPos;
           s6 = input.substr(peg$currPos, 9);
-          if (s6.toLowerCase() === peg$c37) {
+          if (s6.toLowerCase() === peg$c41) {
             peg$currPos += (9);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e41); }
+            if (peg$silentFails === 0) { peg$fail(peg$e45); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$currPos;
@@ -45929,11 +55444,11 @@ function peg$parse(input, options) {
           if (s5 === peg$FAILED) {
             s5 = peg$currPos;
             s6 = input.substr(peg$currPos, 5);
-            if (s6.toLowerCase() === peg$c38) {
+            if (s6.toLowerCase() === peg$c42) {
               peg$currPos += (5);
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e42); }
+              if (peg$silentFails === 0) { peg$fail(peg$e46); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$currPos;
@@ -45966,11 +55481,11 @@ function peg$parse(input, options) {
             if (s5 === peg$FAILED) {
               s5 = peg$currPos;
               s6 = input.substr(peg$currPos, 7);
-              if (s6.toLowerCase() === peg$c39) {
+              if (s6.toLowerCase() === peg$c43) {
                 peg$currPos += (7);
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e43); }
+                if (peg$silentFails === 0) { peg$fail(peg$e47); }
               }
               if (s6 !== peg$FAILED) {
                 s7 = peg$currPos;
@@ -46003,11 +55518,11 @@ function peg$parse(input, options) {
               if (s5 === peg$FAILED) {
                 s5 = peg$currPos;
                 s6 = input.substr(peg$currPos, 5);
-                if (s6.toLowerCase() === peg$c40) {
+                if (s6.toLowerCase() === peg$c44) {
                   peg$currPos += (5);
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e44); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e48); }
                 }
                 if (s6 !== peg$FAILED) {
                   s7 = peg$currPos;
@@ -46040,11 +55555,11 @@ function peg$parse(input, options) {
                 if (s5 === peg$FAILED) {
                   s5 = peg$currPos;
                   s6 = input.substr(peg$currPos, 3);
-                  if (s6.toLowerCase() === peg$c41) {
+                  if (s6.toLowerCase() === peg$c45) {
                     peg$currPos += (3);
                   } else {
                     s6 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e45); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e49); }
                   }
                   if (s6 !== peg$FAILED) {
                     s7 = peg$currPos;
@@ -46077,11 +55592,11 @@ function peg$parse(input, options) {
                   if (s5 === peg$FAILED) {
                     s5 = peg$currPos;
                     s6 = input.substr(peg$currPos, 10);
-                    if (s6.toLowerCase() === peg$c42) {
+                    if (s6.toLowerCase() === peg$c46) {
                       peg$currPos += (10);
                     } else {
                       s6 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e46); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e50); }
                     }
                     if (s6 !== peg$FAILED) {
                       s7 = peg$currPos;
@@ -46114,11 +55629,11 @@ function peg$parse(input, options) {
                     if (s5 === peg$FAILED) {
                       s5 = peg$currPos;
                       s6 = input.substr(peg$currPos, 8);
-                      if (s6.toLowerCase() === peg$c43) {
+                      if (s6.toLowerCase() === peg$c47) {
                         peg$currPos += (8);
                       } else {
                         s6 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e51); }
                       }
                       if (s6 !== peg$FAILED) {
                         s7 = peg$currPos;
@@ -46151,11 +55666,11 @@ function peg$parse(input, options) {
                       if (s5 === peg$FAILED) {
                         s5 = peg$currPos;
                         s6 = input.substr(peg$currPos, 4);
-                        if (s6.toLowerCase() === peg$c44) {
+                        if (s6.toLowerCase() === peg$c48) {
                           peg$currPos += (4);
                         } else {
                           s6 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e52); }
                         }
                         if (s6 !== peg$FAILED) {
                           s7 = peg$currPos;
@@ -46188,11 +55703,11 @@ function peg$parse(input, options) {
                         if (s5 === peg$FAILED) {
                           s5 = peg$currPos;
                           s6 = input.substr(peg$currPos, 3);
-                          if (s6.toLowerCase() === peg$c26) {
+                          if (s6.toLowerCase() === peg$c30) {
                             peg$currPos += (3);
                           } else {
                             s6 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e34); }
                           }
                           if (s6 !== peg$FAILED) {
                             s7 = peg$currPos;
@@ -46214,11 +55729,11 @@ function peg$parse(input, options) {
                             if (s7 !== peg$FAILED) {
                               s8 = peg$parse_();
                               s9 = input.substr(peg$currPos, 4);
-                              if (s9.toLowerCase() === peg$c44) {
+                              if (s9.toLowerCase() === peg$c48) {
                                 peg$currPos += (4);
                               } else {
                                 s9 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                                if (peg$silentFails === 0) { peg$fail(peg$e52); }
                               }
                               if (s9 !== peg$FAILED) {
                                 s10 = peg$currPos;
@@ -46259,11 +55774,11 @@ function peg$parse(input, options) {
                           if (s5 === peg$FAILED) {
                             s5 = peg$currPos;
                             s6 = input.substr(peg$currPos, 14);
-                            if (s6.toLowerCase() === peg$c46) {
+                            if (s6.toLowerCase() === peg$c50) {
                               peg$currPos += (14);
                             } else {
                               s6 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e51); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e55); }
                             }
                             if (s6 !== peg$FAILED) {
                               s7 = peg$currPos;
@@ -46296,11 +55811,11 @@ function peg$parse(input, options) {
                             if (s5 === peg$FAILED) {
                               s5 = peg$currPos;
                               s6 = input.substr(peg$currPos, 7);
-                              if (s6.toLowerCase() === peg$c47) {
+                              if (s6.toLowerCase() === peg$c51) {
                                 peg$currPos += (7);
                               } else {
                                 s6 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e52); }
+                                if (peg$silentFails === 0) { peg$fail(peg$e56); }
                               }
                               if (s6 !== peg$FAILED) {
                                 s7 = peg$currPos;
@@ -46333,11 +55848,11 @@ function peg$parse(input, options) {
                               if (s5 === peg$FAILED) {
                                 s5 = peg$currPos;
                                 s6 = input.substr(peg$currPos, 7);
-                                if (s6.toLowerCase() === peg$c48) {
+                                if (s6.toLowerCase() === peg$c52) {
                                   peg$currPos += (7);
                                 } else {
                                   s6 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e53); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e57); }
                                 }
                                 if (s6 !== peg$FAILED) {
                                   s7 = peg$currPos;
@@ -46373,7 +55888,7 @@ function peg$parse(input, options) {
                                     peg$currPos++;
                                   } else {
                                     s5 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e50); }
+                                    if (peg$silentFails === 0) { peg$fail(peg$e54); }
                                   }
                                 }
                               }
@@ -46415,11 +55930,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       s5 = input.substr(peg$currPos, 7);
-      if (s5.toLowerCase() === peg$c47) {
+      if (s5.toLowerCase() === peg$c51) {
         peg$currPos += (7);
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e52); }
+        if (peg$silentFails === 0) { peg$fail(peg$e56); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$currPos;
@@ -46475,11 +55990,11 @@ function peg$parse(input, options) {
       s5 = peg$currPos;
       s6 = peg$parse_();
       s7 = input.substr(peg$currPos, 14);
-      if (s7.toLowerCase() === peg$c46) {
+      if (s7.toLowerCase() === peg$c50) {
         peg$currPos += (14);
       } else {
         s7 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e51); }
+        if (peg$silentFails === 0) { peg$fail(peg$e55); }
       }
       if (s7 !== peg$FAILED) {
         s8 = peg$currPos;
@@ -46515,11 +56030,11 @@ function peg$parse(input, options) {
       s6 = peg$currPos;
       s7 = peg$parse_();
       s8 = input.substr(peg$currPos, 7);
-      if (s8.toLowerCase() === peg$c48) {
+      if (s8.toLowerCase() === peg$c52) {
         peg$currPos += (7);
       } else {
         s8 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e53); }
+        if (peg$silentFails === 0) { peg$fail(peg$e57); }
       }
       if (s8 !== peg$FAILED) {
         s9 = peg$currPos;
@@ -46541,11 +56056,11 @@ function peg$parse(input, options) {
         if (s9 !== peg$FAILED) {
           s10 = peg$parse_();
           s11 = input.substr(peg$currPos, 3);
-          if (s11.toLowerCase() === peg$c49) {
+          if (s11.toLowerCase() === peg$c53) {
             peg$currPos += (3);
           } else {
             s11 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e54); }
+            if (peg$silentFails === 0) { peg$fail(peg$e58); }
           }
           if (s11 !== peg$FAILED) {
             s12 = peg$currPos;
@@ -46678,7 +56193,7 @@ function peg$parse(input, options) {
         s13 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f346(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13);
+      s0 = peg$f454(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -46692,7 +56207,7 @@ function peg$parse(input, options) {
   function peg$parseNullableModifier() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 209;
+    const key = peg$currPos * 508 + 251;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -46703,11 +56218,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c26) {
+    if (s1.toLowerCase() === peg$c30) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e30); }
+      if (peg$silentFails === 0) { peg$fail(peg$e34); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -46729,11 +56244,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 4);
-        if (s4.toLowerCase() === peg$c44) {
+        if (s4.toLowerCase() === peg$c48) {
           peg$currPos += (4);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e48); }
+          if (peg$silentFails === 0) { peg$fail(peg$e52); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -46754,7 +56269,7 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f347();
+            s0 = peg$f455();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -46774,11 +56289,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c44) {
+      if (s1.toLowerCase() === peg$c48) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e48); }
+        if (peg$silentFails === 0) { peg$fail(peg$e52); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -46799,7 +56314,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f348();
+          s0 = peg$f456();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -46818,7 +56333,7 @@ function peg$parse(input, options) {
   function peg$parseColumnDefault() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
 
-    const key = peg$currPos * 466 + 210;
+    const key = peg$currPos * 508 + 252;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -46857,7 +56372,7 @@ function peg$parse(input, options) {
         s4 = peg$parseTernaryExpr();
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f349(s4);
+          s0 = peg$f457(s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -46873,11 +56388,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 12);
-      if (s1.toLowerCase() === peg$c36) {
+      if (s1.toLowerCase() === peg$c40) {
         peg$currPos += (12);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e40); }
+        if (peg$silentFails === 0) { peg$fail(peg$e44); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -46901,7 +56416,7 @@ function peg$parse(input, options) {
           s4 = peg$parseTernaryExpr();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f350(s4);
+            s0 = peg$f458(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -46917,11 +56432,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 5);
-        if (s1.toLowerCase() === peg$c38) {
+        if (s1.toLowerCase() === peg$c42) {
           peg$currPos += (5);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e42); }
+          if (peg$silentFails === 0) { peg$fail(peg$e46); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -46945,7 +56460,7 @@ function peg$parse(input, options) {
             s4 = peg$parseTernaryExpr();
             if (s4 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f351(s4);
+              s0 = peg$f459(s4);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -46961,11 +56476,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 9);
-          if (s1.toLowerCase() === peg$c37) {
+          if (s1.toLowerCase() === peg$c41) {
             peg$currPos += (9);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e41); }
+            if (peg$silentFails === 0) { peg$fail(peg$e45); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -46991,11 +56506,11 @@ function peg$parse(input, options) {
               peg$silentFails++;
               s6 = peg$currPos;
               s7 = input.substr(peg$currPos, 7);
-              if (s7.toLowerCase() === peg$c39) {
+              if (s7.toLowerCase() === peg$c43) {
                 peg$currPos += (7);
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e43); }
+                if (peg$silentFails === 0) { peg$fail(peg$e47); }
               }
               if (s7 !== peg$FAILED) {
                 s8 = peg$currPos;
@@ -47028,11 +56543,11 @@ function peg$parse(input, options) {
               if (s6 === peg$FAILED) {
                 s6 = peg$currPos;
                 s7 = input.substr(peg$currPos, 5);
-                if (s7.toLowerCase() === peg$c40) {
+                if (s7.toLowerCase() === peg$c44) {
                   peg$currPos += (5);
                 } else {
                   s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e44); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e48); }
                 }
                 if (s7 !== peg$FAILED) {
                   s8 = peg$currPos;
@@ -47065,11 +56580,11 @@ function peg$parse(input, options) {
                 if (s6 === peg$FAILED) {
                   s6 = peg$currPos;
                   s7 = input.substr(peg$currPos, 3);
-                  if (s7.toLowerCase() === peg$c41) {
+                  if (s7.toLowerCase() === peg$c45) {
                     peg$currPos += (3);
                   } else {
                     s7 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e45); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e49); }
                   }
                   if (s7 !== peg$FAILED) {
                     s8 = peg$currPos;
@@ -47102,11 +56617,11 @@ function peg$parse(input, options) {
                   if (s6 === peg$FAILED) {
                     s6 = peg$currPos;
                     s7 = input.substr(peg$currPos, 10);
-                    if (s7.toLowerCase() === peg$c42) {
+                    if (s7.toLowerCase() === peg$c46) {
                       peg$currPos += (10);
                     } else {
                       s7 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e46); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e50); }
                     }
                     if (s7 !== peg$FAILED) {
                       s8 = peg$currPos;
@@ -47139,11 +56654,11 @@ function peg$parse(input, options) {
                     if (s6 === peg$FAILED) {
                       s6 = peg$currPos;
                       s7 = input.substr(peg$currPos, 8);
-                      if (s7.toLowerCase() === peg$c43) {
+                      if (s7.toLowerCase() === peg$c47) {
                         peg$currPos += (8);
                       } else {
                         s7 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e51); }
                       }
                       if (s7 !== peg$FAILED) {
                         s8 = peg$currPos;
@@ -47176,11 +56691,11 @@ function peg$parse(input, options) {
                       if (s6 === peg$FAILED) {
                         s6 = peg$currPos;
                         s7 = input.substr(peg$currPos, 4);
-                        if (s7.toLowerCase() === peg$c44) {
+                        if (s7.toLowerCase() === peg$c48) {
                           peg$currPos += (4);
                         } else {
                           s7 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e52); }
                         }
                         if (s7 !== peg$FAILED) {
                           s8 = peg$currPos;
@@ -47213,11 +56728,11 @@ function peg$parse(input, options) {
                         if (s6 === peg$FAILED) {
                           s6 = peg$currPos;
                           s7 = input.substr(peg$currPos, 3);
-                          if (s7.toLowerCase() === peg$c26) {
+                          if (s7.toLowerCase() === peg$c30) {
                             peg$currPos += (3);
                           } else {
                             s7 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e34); }
                           }
                           if (s7 !== peg$FAILED) {
                             s8 = peg$currPos;
@@ -47239,11 +56754,11 @@ function peg$parse(input, options) {
                             if (s8 !== peg$FAILED) {
                               s9 = peg$parse_();
                               s10 = input.substr(peg$currPos, 4);
-                              if (s10.toLowerCase() === peg$c44) {
+                              if (s10.toLowerCase() === peg$c48) {
                                 peg$currPos += (4);
                               } else {
                                 s10 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                                if (peg$silentFails === 0) { peg$fail(peg$e52); }
                               }
                               if (s10 !== peg$FAILED) {
                                 s11 = peg$currPos;
@@ -47287,7 +56802,7 @@ function peg$parse(input, options) {
                               peg$currPos++;
                             } else {
                               s6 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e50); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e54); }
                             }
                           }
                         }
@@ -47320,7 +56835,7 @@ function peg$parse(input, options) {
                 s3 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f352(s3);
+              s0 = peg$f460(s3);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -47341,7 +56856,7 @@ function peg$parse(input, options) {
   function peg$parseColumnComment() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 211;
+    const key = peg$currPos * 508 + 253;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -47352,11 +56867,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c39) {
+    if (s1.toLowerCase() === peg$c43) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e43); }
+      if (peg$silentFails === 0) { peg$fail(peg$e47); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -47380,7 +56895,7 @@ function peg$parse(input, options) {
         s4 = peg$parseStringLiteral();
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f353(s4);
+          s0 = peg$f461(s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -47402,7 +56917,7 @@ function peg$parse(input, options) {
   function peg$parseColumnCodec() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 212;
+    const key = peg$currPos * 508 + 254;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -47413,11 +56928,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c40) {
+    if (s1.toLowerCase() === peg$c44) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e44); }
+      if (peg$silentFails === 0) { peg$fail(peg$e48); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -47439,11 +56954,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s4 = peg$c21;
+          s4 = peg$c25;
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$parse_();
@@ -47451,15 +56966,15 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s8 = peg$c22;
+              s8 = peg$c26;
               peg$currPos++;
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s8 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f354(s6);
+              s0 = peg$f462(s6);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -47489,7 +57004,7 @@ function peg$parse(input, options) {
   function peg$parseCodecItemList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 213;
+    const key = peg$currPos * 508 + 255;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -47505,11 +57020,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -47530,11 +57045,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -47552,7 +57067,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f355(s1, s2);
+      s0 = peg$f463(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -47566,7 +57081,7 @@ function peg$parse(input, options) {
   function peg$parseCodecItemEntry() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 214;
+    const key = peg$currPos * 508 + 256;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -47579,29 +57094,29 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     s2 = peg$currPos;
     s3 = input.charAt(peg$currPos);
-    if (peg$r8.test(s3)) {
+    if (peg$r5.test(s3)) {
       peg$currPos++;
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e184); }
+      if (peg$silentFails === 0) { peg$fail(peg$e129); }
     }
     if (s3 !== peg$FAILED) {
       s4 = [];
       s5 = input.charAt(peg$currPos);
-      if (peg$r10.test(s5)) {
+      if (peg$r12.test(s5)) {
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e230); }
+        if (peg$silentFails === 0) { peg$fail(peg$e265); }
       }
       while (s5 !== peg$FAILED) {
         s4.push(s5);
         s5 = input.charAt(peg$currPos);
-        if (peg$r10.test(s5)) {
+        if (peg$r12.test(s5)) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e230); }
+          if (peg$silentFails === 0) { peg$fail(peg$e265); }
         }
       }
       s3 = [s3, s4];
@@ -47619,11 +57134,11 @@ function peg$parse(input, options) {
       s2 = peg$currPos;
       s3 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s4 = peg$c21;
+        s4 = peg$c25;
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s4 !== peg$FAILED) {
         s5 = peg$parse_();
@@ -47633,11 +57148,11 @@ function peg$parse(input, options) {
         }
         s7 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s8 = peg$c22;
+          s8 = peg$c26;
           peg$currPos++;
         } else {
           s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s8 !== peg$FAILED) {
           s3 = [s3, s4, s5, s6, s7, s8];
@@ -47654,7 +57169,7 @@ function peg$parse(input, options) {
         s2 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f356(s1, s2);
+      s0 = peg$f464(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -47662,31 +57177,31 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 39) {
-        s1 = peg$c108;
+        s1 = peg$c99;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e113); }
+        if (peg$silentFails === 0) { peg$fail(peg$e104); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
         s3 = [];
         s4 = input.charAt(peg$currPos);
-        if (peg$r5.test(s4)) {
+        if (peg$r8.test(s4)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e178); }
+          if (peg$silentFails === 0) { peg$fail(peg$e219); }
         }
         if (s4 !== peg$FAILED) {
           while (s4 !== peg$FAILED) {
             s3.push(s4);
             s4 = input.charAt(peg$currPos);
-            if (peg$r5.test(s4)) {
+            if (peg$r8.test(s4)) {
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e178); }
+              if (peg$silentFails === 0) { peg$fail(peg$e219); }
             }
           }
         } else {
@@ -47699,21 +57214,21 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           if (input.charCodeAt(peg$currPos) === 39) {
-            s3 = peg$c108;
+            s3 = peg$c99;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e113); }
+            if (peg$silentFails === 0) { peg$fail(peg$e104); }
           }
           if (s3 !== peg$FAILED) {
             s4 = peg$currPos;
             s5 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s6 = peg$c21;
+              s6 = peg$c25;
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$parse_();
@@ -47723,11 +57238,11 @@ function peg$parse(input, options) {
               }
               s9 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s10 = peg$c22;
+                s10 = peg$c26;
                 peg$currPos++;
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s10 !== peg$FAILED) {
                 s5 = [s5, s6, s7, s8, s9, s10];
@@ -47744,7 +57259,7 @@ function peg$parse(input, options) {
               s4 = null;
             }
             peg$savedPos = s0;
-            s0 = peg$f357(s2, s4);
+            s0 = peg$f465(s2, s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -47760,31 +57275,31 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 96) {
-          s1 = peg$c219;
+          s1 = peg$c124;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e231); }
+          if (peg$silentFails === 0) { peg$fail(peg$e133); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
           s3 = [];
           s4 = input.charAt(peg$currPos);
-          if (peg$r11.test(s4)) {
+          if (peg$r13.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e232); }
+            if (peg$silentFails === 0) { peg$fail(peg$e266); }
           }
           if (s4 !== peg$FAILED) {
             while (s4 !== peg$FAILED) {
               s3.push(s4);
               s4 = input.charAt(peg$currPos);
-              if (peg$r11.test(s4)) {
+              if (peg$r13.test(s4)) {
                 peg$currPos++;
               } else {
                 s4 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e232); }
+                if (peg$silentFails === 0) { peg$fail(peg$e266); }
               }
             }
           } else {
@@ -47797,21 +57312,21 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 96) {
-              s3 = peg$c219;
+              s3 = peg$c124;
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e231); }
+              if (peg$silentFails === 0) { peg$fail(peg$e133); }
             }
             if (s3 !== peg$FAILED) {
               s4 = peg$currPos;
               s5 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 40) {
-                s6 = peg$c21;
+                s6 = peg$c25;
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                if (peg$silentFails === 0) { peg$fail(peg$e29); }
               }
               if (s6 !== peg$FAILED) {
                 s7 = peg$parse_();
@@ -47821,11 +57336,11 @@ function peg$parse(input, options) {
                 }
                 s9 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 41) {
-                  s10 = peg$c22;
+                  s10 = peg$c26;
                   peg$currPos++;
                 } else {
                   s10 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
                 if (s10 !== peg$FAILED) {
                   s5 = [s5, s6, s7, s8, s9, s10];
@@ -47842,7 +57357,7 @@ function peg$parse(input, options) {
                 s4 = null;
               }
               peg$savedPos = s0;
-              s0 = peg$f358(s2, s4);
+              s0 = peg$f466(s2, s4);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -47866,7 +57381,7 @@ function peg$parse(input, options) {
   function peg$parseColumnStatistics() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 215;
+    const key = peg$currPos * 508 + 257;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -47877,11 +57392,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 10);
-    if (s1.toLowerCase() === peg$c42) {
+    if (s1.toLowerCase() === peg$c46) {
       peg$currPos += (10);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e46); }
+      if (peg$silentFails === 0) { peg$fail(peg$e50); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -47903,11 +57418,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s4 = peg$c21;
+          s4 = peg$c25;
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$parse_();
@@ -47915,15 +57430,15 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s8 = peg$c22;
+              s8 = peg$c26;
               peg$currPos++;
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s8 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f359(s6);
+              s0 = peg$f467(s6);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -47953,7 +57468,7 @@ function peg$parse(input, options) {
   function peg$parseColumnTTL() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 216;
+    const key = peg$currPos * 508 + 258;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -47964,11 +57479,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c41) {
+    if (s1.toLowerCase() === peg$c45) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e45); }
+      if (peg$silentFails === 0) { peg$fail(peg$e49); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -47992,7 +57507,7 @@ function peg$parse(input, options) {
         s4 = peg$parseExpression();
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f360(s4);
+          s0 = peg$f468(s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -48014,7 +57529,7 @@ function peg$parse(input, options) {
   function peg$parseColumnSettings() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
 
-    const key = peg$currPos * 466 + 217;
+    const key = peg$currPos * 508 + 259;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -48025,11 +57540,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c43) {
+    if (s1.toLowerCase() === peg$c47) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e47); }
+      if (peg$silentFails === 0) { peg$fail(peg$e51); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -48051,11 +57566,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s4 = peg$c21;
+          s4 = peg$c25;
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$parse_();
@@ -48065,11 +57580,11 @@ function peg$parse(input, options) {
             s8 = peg$currPos;
             s9 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 44) {
-              s10 = peg$c15;
+              s10 = peg$c24;
               peg$currPos++;
             } else {
               s10 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e17); }
+              if (peg$silentFails === 0) { peg$fail(peg$e28); }
             }
             if (s10 !== peg$FAILED) {
               s11 = peg$parse_();
@@ -48090,11 +57605,11 @@ function peg$parse(input, options) {
               s8 = peg$currPos;
               s9 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s10 = peg$c15;
+                s10 = peg$c24;
                 peg$currPos++;
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s10 !== peg$FAILED) {
                 s11 = peg$parse_();
@@ -48113,15 +57628,15 @@ function peg$parse(input, options) {
             }
             s8 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s9 = peg$c22;
+              s9 = peg$c26;
               peg$currPos++;
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s9 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f361(s6, s7);
+              s0 = peg$f469(s6, s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -48151,7 +57666,7 @@ function peg$parse(input, options) {
   function peg$parseColumnSettingItem() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 218;
+    const key = peg$currPos * 508 + 260;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -48164,11 +57679,11 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     s2 = peg$currPos;
     s3 = input.charAt(peg$currPos);
-    if (peg$r8.test(s3)) {
+    if (peg$r5.test(s3)) {
       peg$currPos++;
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e184); }
+      if (peg$silentFails === 0) { peg$fail(peg$e129); }
     }
     if (s3 !== peg$FAILED) {
       s4 = [];
@@ -48203,18 +57718,18 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 61) {
-        s3 = peg$c62;
+        s3 = peg$c66;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e67); }
+        if (peg$silentFails === 0) { peg$fail(peg$e71); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$parseTernaryExpr();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f362(s1, s5);
+          s0 = peg$f470(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -48236,7 +57751,7 @@ function peg$parse(input, options) {
   function peg$parseConstraintElement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 219;
+    const key = peg$currPos * 508 + 261;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -48247,11 +57762,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 10);
-    if (s1.toLowerCase() === peg$c59) {
+    if (s1.toLowerCase() === peg$c63) {
       peg$currPos += (10);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e64); }
+      if (peg$silentFails === 0) { peg$fail(peg$e68); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -48276,19 +57791,19 @@ function peg$parse(input, options) {
         if (s4 !== peg$FAILED) {
           s5 = peg$parse_();
           s6 = input.substr(peg$currPos, 5);
-          if (s6.toLowerCase() === peg$c55) {
+          if (s6.toLowerCase() === peg$c59) {
             peg$currPos += (5);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e60); }
+            if (peg$silentFails === 0) { peg$fail(peg$e64); }
           }
           if (s6 === peg$FAILED) {
             s6 = input.substr(peg$currPos, 6);
-            if (s6.toLowerCase() === peg$c56) {
+            if (s6.toLowerCase() === peg$c60) {
               peg$currPos += (6);
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e61); }
+              if (peg$silentFails === 0) { peg$fail(peg$e65); }
             }
           }
           if (s6 !== peg$FAILED) {
@@ -48313,7 +57828,7 @@ function peg$parse(input, options) {
               s9 = peg$parseExpression();
               if (s9 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f363(s4, s6, s9);
+                s0 = peg$f471(s4, s6, s9);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -48347,7 +57862,7 @@ function peg$parse(input, options) {
   function peg$parseForeignKeyElement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26;
 
-    const key = peg$currPos * 466 + 220;
+    const key = peg$currPos * 508 + 262;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -48358,11 +57873,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c220) {
+    if (s1.toLowerCase() === peg$c252) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e233); }
+      if (peg$silentFails === 0) { peg$fail(peg$e267); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -48384,11 +57899,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 3);
-        if (s4.toLowerCase() === peg$c49) {
+        if (s4.toLowerCase() === peg$c53) {
           peg$currPos += (3);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e54); }
+          if (peg$silentFails === 0) { peg$fail(peg$e58); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -48410,11 +57925,11 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s7 = peg$c21;
+              s7 = peg$c25;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
@@ -48422,20 +57937,20 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 41) {
-                  s11 = peg$c22;
+                  s11 = peg$c26;
                   peg$currPos++;
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$parse_();
                   s13 = input.substr(peg$currPos, 10);
-                  if (s13.toLowerCase() === peg$c221) {
+                  if (s13.toLowerCase() === peg$c253) {
                     peg$currPos += (10);
                   } else {
                     s13 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e234); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e268); }
                   }
                   if (s13 !== peg$FAILED) {
                     s14 = peg$currPos;
@@ -48460,11 +57975,11 @@ function peg$parse(input, options) {
                       if (s16 !== peg$FAILED) {
                         s17 = peg$parse_();
                         if (input.charCodeAt(peg$currPos) === 40) {
-                          s18 = peg$c21;
+                          s18 = peg$c25;
                           peg$currPos++;
                         } else {
                           s18 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e29); }
                         }
                         if (s18 !== peg$FAILED) {
                           s19 = peg$parse_();
@@ -48472,11 +57987,11 @@ function peg$parse(input, options) {
                           if (s20 !== peg$FAILED) {
                             s21 = peg$parse_();
                             if (input.charCodeAt(peg$currPos) === 41) {
-                              s22 = peg$c22;
+                              s22 = peg$c26;
                               peg$currPos++;
                             } else {
                               s22 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e30); }
                             }
                             if (s22 !== peg$FAILED) {
                               s23 = [];
@@ -48504,7 +58019,7 @@ function peg$parse(input, options) {
                                 }
                               }
                               peg$savedPos = s0;
-                              s0 = peg$f364(s9, s16, s20, s23);
+                              s0 = peg$f472(s9, s16, s20, s23);
                             } else {
                               peg$currPos = s0;
                               s0 = peg$FAILED;
@@ -48566,7 +58081,7 @@ function peg$parse(input, options) {
   function peg$parseForeignKeyAction() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 221;
+    const key = peg$currPos * 508 + 263;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -48577,11 +58092,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c103) {
+    if (s1.toLowerCase() === peg$c94) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e108); }
+      if (peg$silentFails === 0) { peg$fail(peg$e99); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -48603,19 +58118,19 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c63) {
+        if (s4.toLowerCase() === peg$c67) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e68); }
+          if (peg$silentFails === 0) { peg$fail(peg$e72); }
         }
         if (s4 === peg$FAILED) {
           s4 = input.substr(peg$currPos, 6);
-          if (s4.toLowerCase() === peg$c60) {
+          if (s4.toLowerCase() === peg$c64) {
             peg$currPos += (6);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e65); }
+            if (peg$silentFails === 0) { peg$fail(peg$e69); }
           }
         }
         if (s4 !== peg$FAILED) {
@@ -48638,19 +58153,19 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = input.substr(peg$currPos, 7);
-            if (s7.toLowerCase() === peg$c222) {
+            if (s7.toLowerCase() === peg$c254) {
               peg$currPos += (7);
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e235); }
+              if (peg$silentFails === 0) { peg$fail(peg$e269); }
             }
             if (s7 === peg$FAILED) {
               s7 = input.substr(peg$currPos, 8);
-              if (s7.toLowerCase() === peg$c223) {
+              if (s7.toLowerCase() === peg$c255) {
                 peg$currPos += (8);
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e236); }
+                if (peg$silentFails === 0) { peg$fail(peg$e270); }
               }
               if (s7 === peg$FAILED) {
                 s7 = peg$currPos;
@@ -48681,11 +58196,11 @@ function peg$parse(input, options) {
                   if (s9 !== peg$FAILED) {
                     s10 = peg$parse_();
                     s11 = input.substr(peg$currPos, 4);
-                    if (s11.toLowerCase() === peg$c44) {
+                    if (s11.toLowerCase() === peg$c48) {
                       peg$currPos += (4);
                     } else {
                       s11 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e52); }
                     }
                     if (s11 !== peg$FAILED) {
                       s8 = [s8, s9, s10, s11];
@@ -48705,11 +58220,11 @@ function peg$parse(input, options) {
                 if (s7 === peg$FAILED) {
                   s7 = peg$currPos;
                   s8 = input.substr(peg$currPos, 2);
-                  if (s8.toLowerCase() === peg$c106) {
+                  if (s8.toLowerCase() === peg$c97) {
                     peg$currPos += (2);
                   } else {
                     s8 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e111); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e102); }
                   }
                   if (s8 !== peg$FAILED) {
                     s9 = peg$currPos;
@@ -48731,11 +58246,11 @@ function peg$parse(input, options) {
                     if (s9 !== peg$FAILED) {
                       s10 = peg$parse_();
                       s11 = input.substr(peg$currPos, 6);
-                      if (s11.toLowerCase() === peg$c224) {
+                      if (s11.toLowerCase() === peg$c256) {
                         peg$currPos += (6);
                       } else {
                         s11 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e237); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e271); }
                       }
                       if (s11 !== peg$FAILED) {
                         s8 = [s8, s9, s10, s11];
@@ -48808,7 +58323,7 @@ function peg$parse(input, options) {
   function peg$parseIndexElement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19;
 
-    const key = peg$currPos * 466 + 222;
+    const key = peg$currPos * 508 + 264;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -48819,11 +58334,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c54) {
+    if (s1.toLowerCase() === peg$c58) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e59); }
+      if (peg$silentFails === 0) { peg$fail(peg$e63); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -48851,11 +58366,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 4);
-            if (s8.toLowerCase() === peg$c33) {
+            if (s8.toLowerCase() === peg$c37) {
               peg$currPos += (4);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e37); }
+              if (peg$silentFails === 0) { peg$fail(peg$e41); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -48881,11 +58396,11 @@ function peg$parse(input, options) {
                   s12 = peg$currPos;
                   s13 = peg$parse_();
                   s14 = input.substr(peg$currPos, 11);
-                  if (s14.toLowerCase() === peg$c57) {
+                  if (s14.toLowerCase() === peg$c61) {
                     peg$currPos += (11);
                   } else {
                     s14 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e62); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e66); }
                   }
                   if (s14 !== peg$FAILED) {
                     s15 = peg$currPos;
@@ -48936,7 +58451,7 @@ function peg$parse(input, options) {
                       }
                       if (s17 !== peg$FAILED) {
                         peg$savedPos = s12;
-                        s12 = peg$f365(s4, s6, s11, s17);
+                        s12 = peg$f473(s4, s6, s11, s17);
                       } else {
                         peg$currPos = s12;
                         s12 = peg$FAILED;
@@ -48953,7 +58468,7 @@ function peg$parse(input, options) {
                     s12 = null;
                   }
                   peg$savedPos = s0;
-                  s0 = peg$f366(s4, s6, s11, s12);
+                  s0 = peg$f474(s4, s6, s11, s12);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -48991,7 +58506,7 @@ function peg$parse(input, options) {
   function peg$parseIndexExpr() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 223;
+    const key = peg$currPos * 508 + 265;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -49002,11 +58517,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
@@ -49016,11 +58531,11 @@ function peg$parse(input, options) {
         s5 = peg$currPos;
         s6 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s7 = peg$c15;
+          s7 = peg$c24;
           peg$currPos++;
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s7 !== peg$FAILED) {
           s8 = peg$parse_();
@@ -49041,11 +58556,11 @@ function peg$parse(input, options) {
           s5 = peg$currPos;
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s7 = peg$c15;
+            s7 = peg$c24;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$parse_();
@@ -49064,15 +58579,15 @@ function peg$parse(input, options) {
         }
         s5 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s6 = peg$c22;
+          s6 = peg$c26;
           peg$currPos++;
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s6 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f367(s3, s4);
+          s0 = peg$f475(s3, s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -49097,7 +58612,7 @@ function peg$parse(input, options) {
   function peg$parseIndexTypeSpec() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 224;
+    const key = peg$currPos * 508 + 266;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -49110,11 +58625,11 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     s2 = peg$currPos;
     s3 = input.charAt(peg$currPos);
-    if (peg$r8.test(s3)) {
+    if (peg$r5.test(s3)) {
       peg$currPos++;
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e184); }
+      if (peg$silentFails === 0) { peg$fail(peg$e129); }
     }
     if (s3 !== peg$FAILED) {
       s4 = [];
@@ -49150,11 +58665,11 @@ function peg$parse(input, options) {
       s2 = peg$currPos;
       s3 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s4 = peg$c21;
+        s4 = peg$c25;
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s4 !== peg$FAILED) {
         s5 = peg$parse_();
@@ -49164,11 +58679,11 @@ function peg$parse(input, options) {
         }
         s7 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s8 = peg$c22;
+          s8 = peg$c26;
           peg$currPos++;
         } else {
           s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s8 !== peg$FAILED) {
           s3 = [s3, s4, s5, s6, s7, s8];
@@ -49185,7 +58700,7 @@ function peg$parse(input, options) {
         s2 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f368(s1, s2);
+      s0 = peg$f476(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -49199,7 +58714,7 @@ function peg$parse(input, options) {
   function peg$parseIndexTypeArgList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 225;
+    const key = peg$currPos * 508 + 267;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -49215,11 +58730,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -49240,11 +58755,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -49262,7 +58777,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f369(s1, s2);
+      s0 = peg$f477(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -49276,7 +58791,7 @@ function peg$parse(input, options) {
   function peg$parseProjectionElement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23;
 
-    const key = peg$currPos * 466 + 226;
+    const key = peg$currPos * 508 + 268;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -49287,11 +58802,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 10);
-    if (s1.toLowerCase() === peg$c58) {
+    if (s1.toLowerCase() === peg$c62) {
       peg$currPos += (10);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e63); }
+      if (peg$silentFails === 0) { peg$fail(peg$e67); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -49316,11 +58831,11 @@ function peg$parse(input, options) {
         if (s4 !== peg$FAILED) {
           s5 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 40) {
-            s6 = peg$c21;
+            s6 = peg$c25;
             peg$currPos++;
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
@@ -49328,21 +58843,21 @@ function peg$parse(input, options) {
             if (s8 !== peg$FAILED) {
               s9 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s10 = peg$c22;
+                s10 = peg$c26;
                 peg$currPos++;
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s10 !== peg$FAILED) {
                 s11 = peg$currPos;
                 s12 = peg$parse_();
                 s13 = input.substr(peg$currPos, 4);
-                if (s13.toLowerCase() === peg$c53) {
+                if (s13.toLowerCase() === peg$c57) {
                   peg$currPos += (4);
                 } else {
                   s13 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e58); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e62); }
                 }
                 if (s13 !== peg$FAILED) {
                   s14 = peg$currPos;
@@ -49364,11 +58879,11 @@ function peg$parse(input, options) {
                   if (s14 !== peg$FAILED) {
                     s15 = peg$parse_();
                     s16 = input.substr(peg$currPos, 8);
-                    if (s16.toLowerCase() === peg$c43) {
+                    if (s16.toLowerCase() === peg$c47) {
                       peg$currPos += (8);
                     } else {
                       s16 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e51); }
                     }
                     if (s16 !== peg$FAILED) {
                       s17 = peg$currPos;
@@ -49390,11 +58905,11 @@ function peg$parse(input, options) {
                       if (s17 !== peg$FAILED) {
                         s18 = peg$parse_();
                         if (input.charCodeAt(peg$currPos) === 40) {
-                          s19 = peg$c21;
+                          s19 = peg$c25;
                           peg$currPos++;
                         } else {
                           s19 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e29); }
                         }
                         if (s19 !== peg$FAILED) {
                           s20 = peg$parse_();
@@ -49402,11 +58917,11 @@ function peg$parse(input, options) {
                           if (s21 !== peg$FAILED) {
                             s22 = peg$parse_();
                             if (input.charCodeAt(peg$currPos) === 41) {
-                              s23 = peg$c22;
+                              s23 = peg$c26;
                               peg$currPos++;
                             } else {
                               s23 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e30); }
                             }
                             if (s23 !== peg$FAILED) {
                               s12 = [s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23];
@@ -49443,7 +58958,7 @@ function peg$parse(input, options) {
                   s11 = null;
                 }
                 peg$savedPos = s0;
-                s0 = peg$f370(s4, s8, s11);
+                s0 = peg$f478(s4, s8, s11);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -49477,7 +58992,7 @@ function peg$parse(input, options) {
   function peg$parsePrimaryKeyElement() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 227;
+    const key = peg$currPos * 508 + 269;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -49488,11 +59003,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c48) {
+    if (s1.toLowerCase() === peg$c52) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e53); }
+      if (peg$silentFails === 0) { peg$fail(peg$e57); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -49514,11 +59029,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 3);
-        if (s4.toLowerCase() === peg$c49) {
+        if (s4.toLowerCase() === peg$c53) {
           peg$currPos += (3);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e54); }
+          if (peg$silentFails === 0) { peg$fail(peg$e58); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -49542,7 +59057,7 @@ function peg$parse(input, options) {
             s7 = peg$parsePrimaryKeyExprs();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f371(s7);
+              s0 = peg$f479(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -49572,7 +59087,7 @@ function peg$parse(input, options) {
   function peg$parsePrimaryKeyExprs() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 228;
+    const key = peg$currPos * 508 + 270;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -49583,24 +59098,24 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 41) {
-        s3 = peg$c22;
+        s3 = peg$c26;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e26); }
+        if (peg$silentFails === 0) { peg$fail(peg$e30); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f372();
+        s0 = peg$f480();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -49612,11 +59127,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 40) {
-        s1 = peg$c21;
+        s1 = peg$c25;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
@@ -49626,11 +59141,11 @@ function peg$parse(input, options) {
           s5 = peg$currPos;
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s7 = peg$c15;
+            s7 = peg$c24;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$parse_();
@@ -49651,11 +59166,11 @@ function peg$parse(input, options) {
             s5 = peg$currPos;
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 44) {
-              s7 = peg$c15;
+              s7 = peg$c24;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e17); }
+              if (peg$silentFails === 0) { peg$fail(peg$e28); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
@@ -49674,15 +59189,15 @@ function peg$parse(input, options) {
           }
           s5 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 41) {
-            s6 = peg$c22;
+            s6 = peg$c26;
             peg$currPos++;
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e26); }
+            if (peg$silentFails === 0) { peg$fail(peg$e30); }
           }
           if (s6 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f373(s3, s4);
+            s0 = peg$f481(s3, s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -49700,7 +59215,7 @@ function peg$parse(input, options) {
         s1 = peg$parseExpression();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f374(s1);
+          s1 = peg$f482(s1);
         }
         s0 = s1;
       }
@@ -49714,7 +59229,7 @@ function peg$parse(input, options) {
   function peg$parseEngineClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 229;
+    const key = peg$currPos * 508 + 271;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -49725,11 +59240,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c217) {
+    if (s1.toLowerCase() === peg$c250) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e228); }
+      if (peg$silentFails === 0) { peg$fail(peg$e263); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -49751,11 +59266,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 61) {
-          s4 = peg$c62;
+          s4 = peg$c66;
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e67); }
+          if (peg$silentFails === 0) { peg$fail(peg$e71); }
         }
         if (s4 === peg$FAILED) {
           s4 = null;
@@ -49766,11 +59281,11 @@ function peg$parse(input, options) {
           s7 = peg$currPos;
           s8 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 40) {
-            s9 = peg$c21;
+            s9 = peg$c25;
             peg$currPos++;
           } else {
             s9 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s9 !== peg$FAILED) {
             s10 = peg$parse_();
@@ -49780,11 +59295,11 @@ function peg$parse(input, options) {
             }
             s12 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s13 = peg$c22;
+              s13 = peg$c26;
               peg$currPos++;
             } else {
               s13 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s13 !== peg$FAILED) {
               s8 = [s8, s9, s10, s11, s12, s13];
@@ -49801,7 +59316,7 @@ function peg$parse(input, options) {
             s7 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f375(s6, s7);
+          s0 = peg$f483(s6, s7);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -49823,7 +59338,7 @@ function peg$parse(input, options) {
   function peg$parseEngineArgList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 230;
+    const key = peg$currPos * 508 + 272;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -49839,11 +59354,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -49864,11 +59379,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -49886,7 +59401,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f376(s1, s2);
+      s0 = peg$f484(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -49900,7 +59415,7 @@ function peg$parse(input, options) {
   function peg$parseCreateTableClauses() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 231;
+    const key = peg$currPos * 508 + 273;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -49935,7 +59450,7 @@ function peg$parse(input, options) {
       }
     }
     peg$savedPos = s0;
-    s1 = peg$f377(s1);
+    s1 = peg$f485(s1);
     s0 = s1;
 
     peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -49946,7 +59461,7 @@ function peg$parse(input, options) {
   function peg$parseCreateTableClause() {
     let s0, s1;
 
-    const key = peg$currPos * 466 + 232;
+    const key = peg$currPos * 508 + 274;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -49959,7 +59474,7 @@ function peg$parse(input, options) {
     s1 = peg$parseCreateOrderByClause();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f378(s1);
+      s1 = peg$f486(s1);
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
@@ -49967,7 +59482,7 @@ function peg$parse(input, options) {
       s1 = peg$parseCreatePartitionByClause();
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f379(s1);
+        s1 = peg$f487(s1);
       }
       s0 = s1;
       if (s0 === peg$FAILED) {
@@ -49975,7 +59490,7 @@ function peg$parse(input, options) {
         s1 = peg$parseCreatePrimaryKeyClause();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f380(s1);
+          s1 = peg$f488(s1);
         }
         s0 = s1;
         if (s0 === peg$FAILED) {
@@ -49983,7 +59498,7 @@ function peg$parse(input, options) {
           s1 = peg$parseCreateSampleByClause();
           if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
-            s1 = peg$f381(s1);
+            s1 = peg$f489(s1);
           }
           s0 = s1;
           if (s0 === peg$FAILED) {
@@ -49991,7 +59506,7 @@ function peg$parse(input, options) {
             s1 = peg$parseCreateTTLClause();
             if (s1 !== peg$FAILED) {
               peg$savedPos = s0;
-              s1 = peg$f382(s1);
+              s1 = peg$f490(s1);
             }
             s0 = s1;
             if (s0 === peg$FAILED) {
@@ -49999,7 +59514,7 @@ function peg$parse(input, options) {
               s1 = peg$parseSettingsClause();
               if (s1 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s1 = peg$f383(s1);
+                s1 = peg$f491(s1);
               }
               s0 = s1;
               if (s0 === peg$FAILED) {
@@ -50007,7 +59522,7 @@ function peg$parse(input, options) {
                 s1 = peg$parseCreateCommentClause();
                 if (s1 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s1 = peg$f384(s1);
+                  s1 = peg$f492(s1);
                 }
                 s0 = s1;
               }
@@ -50025,7 +59540,7 @@ function peg$parse(input, options) {
   function peg$parseCreateOrderByClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 233;
+    const key = peg$currPos * 508 + 275;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -50036,11 +59551,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c79) {
+    if (s1.toLowerCase() === peg$c83) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e84); }
+      if (peg$silentFails === 0) { peg$fail(peg$e88); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -50062,11 +59577,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 2);
-        if (s4.toLowerCase() === peg$c80) {
+        if (s4.toLowerCase() === peg$c84) {
           peg$currPos += (2);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e85); }
+          if (peg$silentFails === 0) { peg$fail(peg$e89); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -50088,11 +59603,11 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s7 = peg$c21;
+              s7 = peg$c25;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
@@ -50102,11 +59617,11 @@ function peg$parse(input, options) {
                 s11 = peg$currPos;
                 s12 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s13 = peg$c15;
+                  s13 = peg$c24;
                   peg$currPos++;
                 } else {
                   s13 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s13 !== peg$FAILED) {
                   s14 = peg$parse_();
@@ -50127,11 +59642,11 @@ function peg$parse(input, options) {
                   s11 = peg$currPos;
                   s12 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 44) {
-                    s13 = peg$c15;
+                    s13 = peg$c24;
                     peg$currPos++;
                   } else {
                     s13 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e28); }
                   }
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
@@ -50150,11 +59665,11 @@ function peg$parse(input, options) {
                 }
                 s11 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 41) {
-                  s12 = peg$c22;
+                  s12 = peg$c26;
                   peg$currPos++;
                 } else {
                   s12 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
                 if (s12 !== peg$FAILED) {
                   s13 = peg$currPos;
@@ -50162,11 +59677,11 @@ function peg$parse(input, options) {
                   s14 = peg$currPos;
                   s15 = peg$parse_();
                   s16 = input.charAt(peg$currPos);
-                  if (peg$r12.test(s16)) {
+                  if (peg$r14.test(s16)) {
                     peg$currPos++;
                   } else {
                     s16 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e238); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e272); }
                   }
                   if (s16 !== peg$FAILED) {
                     s15 = [s15, s16];
@@ -50184,7 +59699,7 @@ function peg$parse(input, options) {
                   }
                   if (s13 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f385(s9, s10);
+                    s0 = peg$f493(s9, s10);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -50220,11 +59735,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c79) {
+      if (s1.toLowerCase() === peg$c83) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e84); }
+        if (peg$silentFails === 0) { peg$fail(peg$e88); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -50246,11 +59761,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 2);
-          if (s4.toLowerCase() === peg$c80) {
+          if (s4.toLowerCase() === peg$c84) {
             peg$currPos += (2);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e85); }
+            if (peg$silentFails === 0) { peg$fail(peg$e89); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -50277,11 +59792,11 @@ function peg$parse(input, options) {
                 s9 = peg$currPos;
                 s10 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s11 = peg$c15;
+                  s11 = peg$c24;
                   peg$currPos++;
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s11 !== peg$FAILED) {
                   s12 = peg$parse_();
@@ -50302,11 +59817,11 @@ function peg$parse(input, options) {
                   s9 = peg$currPos;
                   s10 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 44) {
-                    s11 = peg$c15;
+                    s11 = peg$c24;
                     peg$currPos++;
                   } else {
                     s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e28); }
                   }
                   if (s11 !== peg$FAILED) {
                     s12 = peg$parse_();
@@ -50324,7 +59839,7 @@ function peg$parse(input, options) {
                   }
                 }
                 peg$savedPos = s0;
-                s0 = peg$f386(s7, s8);
+                s0 = peg$f494(s7, s8);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -50355,7 +59870,7 @@ function peg$parse(input, options) {
   function peg$parseCreateOrderByItem() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 234;
+    const key = peg$currPos * 508 + 276;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -50370,19 +59885,19 @@ function peg$parse(input, options) {
       s2 = peg$currPos;
       s3 = peg$parse_();
       s4 = input.substr(peg$currPos, 3);
-      if (s4.toLowerCase() === peg$c164) {
+      if (s4.toLowerCase() === peg$c208) {
         peg$currPos += (3);
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e170); }
+        if (peg$silentFails === 0) { peg$fail(peg$e217); }
       }
       if (s4 === peg$FAILED) {
         s4 = input.substr(peg$currPos, 4);
-        if (s4.toLowerCase() === peg$c130) {
+        if (s4.toLowerCase() === peg$c184) {
           peg$currPos += (4);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e136); }
+          if (peg$silentFails === 0) { peg$fail(peg$e193); }
         }
       }
       if (s4 !== peg$FAILED) {
@@ -50417,7 +59932,7 @@ function peg$parse(input, options) {
         s2 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f387(s1, s2);
+      s0 = peg$f495(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -50431,7 +59946,7 @@ function peg$parse(input, options) {
   function peg$parseCreatePartitionByClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 235;
+    const key = peg$currPos * 508 + 277;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -50442,11 +59957,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 9);
-    if (s1.toLowerCase() === peg$c66) {
+    if (s1.toLowerCase() === peg$c70) {
       peg$currPos += (9);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e71); }
+      if (peg$silentFails === 0) { peg$fail(peg$e75); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -50468,11 +59983,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 2);
-        if (s4.toLowerCase() === peg$c80) {
+        if (s4.toLowerCase() === peg$c84) {
           peg$currPos += (2);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e85); }
+          if (peg$silentFails === 0) { peg$fail(peg$e89); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -50494,24 +60009,24 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s7 = peg$c21;
+              s7 = peg$c25;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s9 = peg$c22;
+                s9 = peg$c26;
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s9 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f388();
+                s0 = peg$f496();
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -50539,11 +60054,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 9);
-      if (s1.toLowerCase() === peg$c66) {
+      if (s1.toLowerCase() === peg$c70) {
         peg$currPos += (9);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e71); }
+        if (peg$silentFails === 0) { peg$fail(peg$e75); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -50565,11 +60080,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 2);
-          if (s4.toLowerCase() === peg$c80) {
+          if (s4.toLowerCase() === peg$c84) {
             peg$currPos += (2);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e85); }
+            if (peg$silentFails === 0) { peg$fail(peg$e89); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -50593,7 +60108,7 @@ function peg$parse(input, options) {
               s7 = peg$parseTernaryExpr();
               if (s7 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f389(s7);
+                s0 = peg$f497(s7);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -50624,7 +60139,7 @@ function peg$parse(input, options) {
   function peg$parseCreatePrimaryKeyClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;
 
-    const key = peg$currPos * 466 + 236;
+    const key = peg$currPos * 508 + 278;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -50635,11 +60150,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c48) {
+    if (s1.toLowerCase() === peg$c52) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e53); }
+      if (peg$silentFails === 0) { peg$fail(peg$e57); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -50661,11 +60176,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 3);
-        if (s4.toLowerCase() === peg$c49) {
+        if (s4.toLowerCase() === peg$c53) {
           peg$currPos += (3);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e54); }
+          if (peg$silentFails === 0) { peg$fail(peg$e58); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -50687,24 +60202,24 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s7 = peg$c21;
+              s7 = peg$c25;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s9 = peg$c22;
+                s9 = peg$c26;
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s9 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f390();
+                s0 = peg$f498();
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -50732,11 +60247,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 7);
-      if (s1.toLowerCase() === peg$c48) {
+      if (s1.toLowerCase() === peg$c52) {
         peg$currPos += (7);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e53); }
+        if (peg$silentFails === 0) { peg$fail(peg$e57); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -50758,11 +60273,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 3);
-          if (s4.toLowerCase() === peg$c49) {
+          if (s4.toLowerCase() === peg$c53) {
             peg$currPos += (3);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e54); }
+            if (peg$silentFails === 0) { peg$fail(peg$e58); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -50784,11 +60299,11 @@ function peg$parse(input, options) {
             if (s5 !== peg$FAILED) {
               s6 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 40) {
-                s7 = peg$c21;
+                s7 = peg$c25;
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                if (peg$silentFails === 0) { peg$fail(peg$e29); }
               }
               if (s7 !== peg$FAILED) {
                 s8 = peg$parse_();
@@ -50798,11 +60313,11 @@ function peg$parse(input, options) {
                   s11 = peg$currPos;
                   s12 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 44) {
-                    s13 = peg$c15;
+                    s13 = peg$c24;
                     peg$currPos++;
                   } else {
                     s13 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e28); }
                   }
                   if (s13 !== peg$FAILED) {
                     s14 = peg$parse_();
@@ -50823,11 +60338,11 @@ function peg$parse(input, options) {
                     s11 = peg$currPos;
                     s12 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 44) {
-                      s13 = peg$c15;
+                      s13 = peg$c24;
                       peg$currPos++;
                     } else {
                       s13 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e28); }
                     }
                     if (s13 !== peg$FAILED) {
                       s14 = peg$parse_();
@@ -50846,15 +60361,15 @@ function peg$parse(input, options) {
                   }
                   s11 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 41) {
-                    s12 = peg$c22;
+                    s12 = peg$c26;
                     peg$currPos++;
                   } else {
                     s12 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
                   }
                   if (s12 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f391(s9, s10);
+                    s0 = peg$f499(s9, s10);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -50886,11 +60401,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 7);
-        if (s1.toLowerCase() === peg$c48) {
+        if (s1.toLowerCase() === peg$c52) {
           peg$currPos += (7);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e53); }
+          if (peg$silentFails === 0) { peg$fail(peg$e57); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -50912,11 +60427,11 @@ function peg$parse(input, options) {
           if (s2 !== peg$FAILED) {
             s3 = peg$parse_();
             s4 = input.substr(peg$currPos, 3);
-            if (s4.toLowerCase() === peg$c49) {
+            if (s4.toLowerCase() === peg$c53) {
               peg$currPos += (3);
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e54); }
+              if (peg$silentFails === 0) { peg$fail(peg$e58); }
             }
             if (s4 !== peg$FAILED) {
               s5 = peg$currPos;
@@ -50940,7 +60455,7 @@ function peg$parse(input, options) {
                 s7 = peg$parseTernaryExpr();
                 if (s7 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f392(s7);
+                  s0 = peg$f500(s7);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -50972,7 +60487,7 @@ function peg$parse(input, options) {
   function peg$parseCreateSampleByClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 237;
+    const key = peg$currPos * 508 + 279;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -50983,11 +60498,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c81) {
+    if (s1.toLowerCase() === peg$c85) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e86); }
+      if (peg$silentFails === 0) { peg$fail(peg$e90); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -51009,11 +60524,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 2);
-        if (s4.toLowerCase() === peg$c80) {
+        if (s4.toLowerCase() === peg$c84) {
           peg$currPos += (2);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e85); }
+          if (peg$silentFails === 0) { peg$fail(peg$e89); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -51037,7 +60552,7 @@ function peg$parse(input, options) {
             s7 = peg$parseTernaryExpr();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f393(s7);
+              s0 = peg$f501(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -51067,7 +60582,7 @@ function peg$parse(input, options) {
   function peg$parseCreateTTLClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 238;
+    const key = peg$currPos * 508 + 280;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -51078,11 +60593,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c41) {
+    if (s1.toLowerCase() === peg$c45) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e45); }
+      if (peg$silentFails === 0) { peg$fail(peg$e49); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -51109,11 +60624,11 @@ function peg$parse(input, options) {
           s6 = peg$currPos;
           s7 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s8 = peg$c15;
+            s8 = peg$c24;
             peg$currPos++;
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s8 !== peg$FAILED) {
             s9 = peg$parse_();
@@ -51134,11 +60649,11 @@ function peg$parse(input, options) {
             s6 = peg$currPos;
             s7 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 44) {
-              s8 = peg$c15;
+              s8 = peg$c24;
               peg$currPos++;
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e17); }
+              if (peg$silentFails === 0) { peg$fail(peg$e28); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$parse_();
@@ -51156,7 +60671,7 @@ function peg$parse(input, options) {
             }
           }
           peg$savedPos = s0;
-          s0 = peg$f394(s4, s5);
+          s0 = peg$f502(s4, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -51178,7 +60693,7 @@ function peg$parse(input, options) {
   function peg$parseTTLItem() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 239;
+    const key = peg$currPos * 508 + 281;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -51204,7 +60719,7 @@ function peg$parse(input, options) {
         s2 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f395(s1, s2);
+      s0 = peg$f503(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -51218,7 +60733,7 @@ function peg$parse(input, options) {
   function peg$parseTTLSuffix() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 240;
+    const key = peg$currPos * 508 + 282;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -51229,11 +60744,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c63) {
+    if (s1.toLowerCase() === peg$c67) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e68); }
+      if (peg$silentFails === 0) { peg$fail(peg$e72); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -51256,11 +60771,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 5);
-        if (s5.toLowerCase() === peg$c61) {
+        if (s5.toLowerCase() === peg$c65) {
           peg$currPos += (5);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e66); }
+          if (peg$silentFails === 0) { peg$fail(peg$e70); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -51301,7 +60816,7 @@ function peg$parse(input, options) {
           s3 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f396(s3);
+        s0 = peg$f504(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -51339,19 +60854,19 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 4);
-          if (s4.toLowerCase() === peg$c72) {
+          if (s4.toLowerCase() === peg$c76) {
             peg$currPos += (4);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e77); }
+            if (peg$silentFails === 0) { peg$fail(peg$e81); }
           }
           if (s4 === peg$FAILED) {
             s4 = input.substr(peg$currPos, 6);
-            if (s4.toLowerCase() === peg$c73) {
+            if (s4.toLowerCase() === peg$c77) {
               peg$currPos += (6);
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e78); }
+              if (peg$silentFails === 0) { peg$fail(peg$e82); }
             }
           }
           if (s4 !== peg$FAILED) {
@@ -51375,11 +60890,11 @@ function peg$parse(input, options) {
               s6 = peg$parse_();
               s7 = peg$currPos;
               s8 = input.substr(peg$currPos, 2);
-              if (s8.toLowerCase() === peg$c25) {
+              if (s8.toLowerCase() === peg$c29) {
                 peg$currPos += (2);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                if (peg$silentFails === 0) { peg$fail(peg$e33); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -51401,11 +60916,11 @@ function peg$parse(input, options) {
                 if (s9 !== peg$FAILED) {
                   s10 = peg$parse_();
                   s11 = input.substr(peg$currPos, 6);
-                  if (s11.toLowerCase() === peg$c27) {
+                  if (s11.toLowerCase() === peg$c31) {
                     peg$currPos += (6);
                   } else {
                     s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e35); }
                   }
                   if (s11 !== peg$FAILED) {
                     s12 = peg$currPos;
@@ -51450,7 +60965,7 @@ function peg$parse(input, options) {
               s8 = peg$parseStringLiteral();
               if (s8 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f397();
+                s0 = peg$f505();
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -51474,11 +60989,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 10);
-        if (s1.toLowerCase() === peg$c225) {
+        if (s1.toLowerCase() === peg$c257) {
           peg$currPos += (10);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e239); }
+          if (peg$silentFails === 0) { peg$fail(peg$e273); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -51502,7 +61017,7 @@ function peg$parse(input, options) {
             s4 = peg$parseColumnCodec();
             if (s4 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f398();
+              s0 = peg$f506();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -51518,11 +61033,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 5);
-          if (s1.toLowerCase() === peg$c61) {
+          if (s1.toLowerCase() === peg$c65) {
             peg$currPos += (5);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e66); }
+            if (peg$silentFails === 0) { peg$fail(peg$e70); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -51546,7 +61061,7 @@ function peg$parse(input, options) {
               s4 = peg$parseTernaryExpr();
               if (s4 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f399(s4);
+                s0 = peg$f507(s4);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -51562,11 +61077,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 5);
-            if (s1.toLowerCase() === peg$c226) {
+            if (s1.toLowerCase() === peg$c258) {
               peg$currPos += (5);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e240); }
+              if (peg$silentFails === 0) { peg$fail(peg$e274); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -51588,11 +61103,11 @@ function peg$parse(input, options) {
               if (s2 !== peg$FAILED) {
                 s3 = peg$parse_();
                 s4 = input.substr(peg$currPos, 2);
-                if (s4.toLowerCase() === peg$c80) {
+                if (s4.toLowerCase() === peg$c84) {
                   peg$currPos += (2);
                 } else {
                   s4 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e85); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e89); }
                 }
                 if (s4 !== peg$FAILED) {
                   s5 = peg$currPos;
@@ -51663,7 +61178,7 @@ function peg$parse(input, options) {
                         s8 = null;
                       }
                       peg$savedPos = s0;
-                      s0 = peg$f400();
+                      s0 = peg$f508();
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -51697,7 +61212,7 @@ function peg$parse(input, options) {
   function peg$parseTTLGroupByList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 241;
+    const key = peg$currPos * 508 + 283;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -51713,11 +61228,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -51738,11 +61253,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -51760,7 +61275,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f401(s1, s2);
+      s0 = peg$f509(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -51774,7 +61289,7 @@ function peg$parse(input, options) {
   function peg$parseTTLSetList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 242;
+    const key = peg$currPos * 508 + 284;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -51790,11 +61305,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -51815,11 +61330,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -51837,7 +61352,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f402(s1, s2);
+      s0 = peg$f510(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -51851,7 +61366,7 @@ function peg$parse(input, options) {
   function peg$parseTTLSetItem() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 243;
+    const key = peg$currPos * 508 + 285;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -51865,18 +61380,18 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 61) {
-        s3 = peg$c62;
+        s3 = peg$c66;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e67); }
+        if (peg$silentFails === 0) { peg$fail(peg$e71); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$parseTernaryExpr();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f403(s1, s5);
+          s0 = peg$f511(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -51898,7 +61413,7 @@ function peg$parse(input, options) {
   function peg$parseCreateCommentClause() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 244;
+    const key = peg$currPos * 508 + 286;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -51909,11 +61424,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c39) {
+    if (s1.toLowerCase() === peg$c43) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e43); }
+      if (peg$silentFails === 0) { peg$fail(peg$e47); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -51937,7 +61452,7 @@ function peg$parse(input, options) {
         s4 = peg$parseStringLiteral();
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f404(s4);
+          s0 = peg$f512(s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -51959,7 +61474,7 @@ function peg$parse(input, options) {
   function peg$parseExplainStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
 
-    const key = peg$currPos * 466 + 245;
+    const key = peg$currPos * 508 + 287;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -51970,11 +61485,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c227) {
+    if (s1.toLowerCase() === peg$c259) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e241); }
+      if (peg$silentFails === 0) { peg$fail(peg$e275); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -52036,7 +61551,7 @@ function peg$parse(input, options) {
           s10 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f405(s4, s6, s8, s9, s10);
+        s0 = peg$f513(s4, s6, s8, s9, s10);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -52054,7 +61569,7 @@ function peg$parse(input, options) {
   function peg$parseExplainInnerStatement() {
     let s0;
 
-    const key = peg$currPos * 466 + 246;
+    const key = peg$currPos * 508 + 288;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -52073,17 +61588,23 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$parseDropStatement();
             if (s0 === peg$FAILED) {
-              s0 = peg$parseTruncateStatement();
+              s0 = peg$parseUndropStatement();
               if (s0 === peg$FAILED) {
-                s0 = peg$parseOptimizeStatement();
+                s0 = peg$parseBackupStatement();
                 if (s0 === peg$FAILED) {
-                  s0 = peg$parseDescribeStatement();
+                  s0 = peg$parseTruncateStatement();
                   if (s0 === peg$FAILED) {
-                    s0 = peg$parseDeleteStatement();
+                    s0 = peg$parseOptimizeStatement();
                     if (s0 === peg$FAILED) {
-                      s0 = peg$parseUpdateStatement();
+                      s0 = peg$parseDescribeStatement();
                       if (s0 === peg$FAILED) {
-                        s0 = peg$parseUnionQuery();
+                        s0 = peg$parseDeleteStatement();
+                        if (s0 === peg$FAILED) {
+                          s0 = peg$parseUpdateStatement();
+                          if (s0 === peg$FAILED) {
+                            s0 = peg$parseUnionQuery();
+                          }
+                        }
                       }
                     }
                   }
@@ -52103,7 +61624,7 @@ function peg$parse(input, options) {
   function peg$parseExplainType() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 247;
+    const key = peg$currPos * 508 + 289;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -52114,11 +61635,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c82) {
+    if (s1.toLowerCase() === peg$c86) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e87); }
+      if (peg$silentFails === 0) { peg$fail(peg$e91); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -52140,11 +61661,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 4);
-        if (s4.toLowerCase() === peg$c228) {
+        if (s4.toLowerCase() === peg$c260) {
           peg$currPos += (4);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e242); }
+          if (peg$silentFails === 0) { peg$fail(peg$e276); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -52165,7 +61686,7 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f406();
+            s0 = peg$f514();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -52185,11 +61706,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c20) {
+      if (s1.toLowerCase() === peg$c23) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e24); }
+        if (peg$silentFails === 0) { peg$fail(peg$e27); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -52211,11 +61732,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 8);
-          if (s4.toLowerCase() === peg$c229) {
+          if (s4.toLowerCase() === peg$c261) {
             peg$currPos += (8);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e243); }
+            if (peg$silentFails === 0) { peg$fail(peg$e277); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -52236,7 +61757,7 @@ function peg$parse(input, options) {
             }
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f407();
+              s0 = peg$f515();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -52256,11 +61777,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 7);
-        if (s1.toLowerCase() === peg$c230) {
+        if (s1.toLowerCase() === peg$c162) {
           peg$currPos += (7);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e244); }
+          if (peg$silentFails === 0) { peg$fail(peg$e171); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -52307,7 +61828,7 @@ function peg$parse(input, options) {
               }
               if (s5 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f408();
+                s0 = peg$f516();
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -52327,11 +61848,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 3);
-          if (s1.toLowerCase() === peg$c231) {
+          if (s1.toLowerCase() === peg$c262) {
             peg$currPos += (3);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e245); }
+            if (peg$silentFails === 0) { peg$fail(peg$e278); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -52352,7 +61873,7 @@ function peg$parse(input, options) {
             }
             if (s2 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f409();
+              s0 = peg$f517();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -52364,11 +61885,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 6);
-            if (s1.toLowerCase() === peg$c232) {
+            if (s1.toLowerCase() === peg$c263) {
               peg$currPos += (6);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e246); }
+              if (peg$silentFails === 0) { peg$fail(peg$e279); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -52389,7 +61910,7 @@ function peg$parse(input, options) {
               }
               if (s2 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f410();
+                s0 = peg$f518();
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -52401,11 +61922,11 @@ function peg$parse(input, options) {
             if (s0 === peg$FAILED) {
               s0 = peg$currPos;
               s1 = input.substr(peg$currPos, 4);
-              if (s1.toLowerCase() === peg$c233) {
+              if (s1.toLowerCase() === peg$c264) {
                 peg$currPos += (4);
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e247); }
+                if (peg$silentFails === 0) { peg$fail(peg$e280); }
               }
               if (s1 !== peg$FAILED) {
                 s2 = peg$currPos;
@@ -52426,7 +61947,7 @@ function peg$parse(input, options) {
                 }
                 if (s2 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f411();
+                  s0 = peg$f519();
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -52438,11 +61959,11 @@ function peg$parse(input, options) {
               if (s0 === peg$FAILED) {
                 s0 = peg$currPos;
                 s1 = input.substr(peg$currPos, 8);
-                if (s1.toLowerCase() === peg$c234) {
+                if (s1.toLowerCase() === peg$c265) {
                   peg$currPos += (8);
                 } else {
                   s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e248); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e281); }
                 }
                 if (s1 !== peg$FAILED) {
                   s2 = peg$currPos;
@@ -52463,7 +61984,7 @@ function peg$parse(input, options) {
                   }
                   if (s2 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f412();
+                    s0 = peg$f520();
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -52475,11 +61996,11 @@ function peg$parse(input, options) {
                 if (s0 === peg$FAILED) {
                   s0 = peg$currPos;
                   s1 = input.substr(peg$currPos, 8);
-                  if (s1.toLowerCase() === peg$c235) {
+                  if (s1.toLowerCase() === peg$c266) {
                     peg$currPos += (8);
                   } else {
                     s1 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e249); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e282); }
                   }
                   if (s1 !== peg$FAILED) {
                     s2 = peg$currPos;
@@ -52500,7 +62021,7 @@ function peg$parse(input, options) {
                     }
                     if (s2 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f413();
+                      s0 = peg$f521();
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -52525,7 +62046,7 @@ function peg$parse(input, options) {
   function peg$parseExplainSettingsList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 248;
+    const key = peg$currPos * 508 + 290;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -52541,11 +62062,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -52566,11 +62087,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -52588,7 +62109,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f414(s1, s2);
+      s0 = peg$f522(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -52602,7 +62123,7 @@ function peg$parse(input, options) {
   function peg$parseExplainSettingItem() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 249;
+    const key = peg$currPos * 508 + 291;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -52616,18 +62137,18 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 61) {
-        s3 = peg$c62;
+        s3 = peg$c66;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e67); }
+        if (peg$silentFails === 0) { peg$fail(peg$e71); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$parseUnaryExpr();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f415(s1, s5);
+          s0 = peg$f523(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -52649,7 +62170,7 @@ function peg$parse(input, options) {
   function peg$parseFormatClause() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 250;
+    const key = peg$currPos * 508 + 292;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -52665,7 +62186,7 @@ function peg$parse(input, options) {
       s3 = peg$parseFormatName();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f416(s3);
+        s0 = peg$f524(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -52683,7 +62204,7 @@ function peg$parse(input, options) {
   function peg$parseFormatName() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 251;
+    const key = peg$currPos * 508 + 293;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -52696,11 +62217,11 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     s2 = peg$currPos;
     s3 = input.charAt(peg$currPos);
-    if (peg$r8.test(s3)) {
+    if (peg$r5.test(s3)) {
       peg$currPos++;
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e184); }
+      if (peg$silentFails === 0) { peg$fail(peg$e129); }
     }
     if (s3 !== peg$FAILED) {
       s4 = [];
@@ -52734,17 +62255,17 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f417(s1);
+      s1 = peg$f525(s1);
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 96) {
-        s1 = peg$c219;
+        s1 = peg$c124;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e231); }
+        if (peg$silentFails === 0) { peg$fail(peg$e133); }
       }
       if (s1 !== peg$FAILED) {
         s2 = [];
@@ -52754,15 +62275,15 @@ function peg$parse(input, options) {
           s3 = peg$parseBacktickChar();
         }
         if (input.charCodeAt(peg$currPos) === 96) {
-          s3 = peg$c219;
+          s3 = peg$c124;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e231); }
+          if (peg$silentFails === 0) { peg$fail(peg$e133); }
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f418(s2);
+          s0 = peg$f526(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -52781,7 +62302,7 @@ function peg$parse(input, options) {
   function peg$parseUnionQuery() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 252;
+    const key = peg$currPos * 508 + 294;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -52832,7 +62353,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f419(s1, s2);
+      s0 = peg$f527(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -52846,7 +62367,7 @@ function peg$parse(input, options) {
   function peg$parseIntersectQuery() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 253;
+    const key = peg$currPos * 508 + 295;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -52897,7 +62418,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f420(s1, s2);
+      s0 = peg$f528(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -52911,7 +62432,7 @@ function peg$parse(input, options) {
   function peg$parseUnionExceptOp() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 254;
+    const key = peg$currPos * 508 + 296;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -52929,7 +62450,7 @@ function peg$parse(input, options) {
         s3 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f421(s3);
+      s0 = peg$f529(s3);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -52975,7 +62496,7 @@ function peg$parse(input, options) {
             s3 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f422();
+          s0 = peg$f530();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -52994,7 +62515,7 @@ function peg$parse(input, options) {
   function peg$parseIntersectOp() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 255;
+    const key = peg$currPos * 508 + 297;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -53005,11 +62526,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 9);
-    if (s1.toLowerCase() === peg$c236) {
+    if (s1.toLowerCase() === peg$c267) {
       peg$currPos += (9);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e250); }
+      if (peg$silentFails === 0) { peg$fail(peg$e283); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -53043,7 +62564,7 @@ function peg$parse(input, options) {
           s3 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f423();
+        s0 = peg$f531();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -53061,7 +62582,7 @@ function peg$parse(input, options) {
   function peg$parseUnionAllOrDistinct() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 256;
+    const key = peg$currPos * 508 + 298;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -53074,17 +62595,17 @@ function peg$parse(input, options) {
     s1 = peg$parseKW_ALL();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f424();
+      s1 = peg$f532();
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 8);
-      if (s1.toLowerCase() === peg$c237) {
+      if (s1.toLowerCase() === peg$c268) {
         peg$currPos += (8);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e251); }
+        if (peg$silentFails === 0) { peg$fail(peg$e284); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -53105,7 +62626,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f425();
+          s0 = peg$f533();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -53155,7 +62676,7 @@ function peg$parse(input, options) {
               s3 = null;
             }
             peg$savedPos = s0;
-            s0 = peg$f426();
+            s0 = peg$f534();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -53175,7 +62696,7 @@ function peg$parse(input, options) {
   function peg$parseUnionQueryAtom() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 257;
+    const key = peg$currPos * 508 + 299;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -53186,11 +62707,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
@@ -53198,15 +62719,15 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s5 = peg$c22;
+          s5 = peg$c26;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f427(s2, s3, s4);
+          s0 = peg$f535(s2, s3, s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -53234,7 +62755,7 @@ function peg$parse(input, options) {
   function peg$parseFromFirstSelectStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19;
 
-    const key = peg$currPos * 466 + 258;
+    const key = peg$currPos * 508 + 300;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -53397,7 +62918,7 @@ function peg$parse(input, options) {
             s17 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f428(s1, s2, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17);
+          s0 = peg$f536(s1, s2, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -53419,7 +62940,7 @@ function peg$parse(input, options) {
   function peg$parseSelectStatement() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26;
 
-    const key = peg$currPos * 466 + 259;
+    const key = peg$currPos * 508 + 301;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -53462,11 +62983,11 @@ function peg$parse(input, options) {
         }
         s5 = peg$currPos;
         s6 = input.substr(peg$currPos, 3);
-        if (s6.toLowerCase() === peg$c238) {
+        if (s6.toLowerCase() === peg$c269) {
           peg$currPos += (3);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e252); }
+          if (peg$silentFails === 0) { peg$fail(peg$e285); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -53495,11 +63016,11 @@ function peg$parse(input, options) {
               if (s12 !== peg$FAILED) {
                 s13 = peg$parse_();
                 s14 = input.substr(peg$currPos, 4);
-                if (s14.toLowerCase() === peg$c239) {
+                if (s14.toLowerCase() === peg$c270) {
                   peg$currPos += (4);
                 } else {
                   s14 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e253); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e286); }
                 }
                 if (s14 !== peg$FAILED) {
                   s15 = peg$currPos;
@@ -53779,7 +63300,7 @@ function peg$parse(input, options) {
             s24 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f429(s1, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24);
+          s0 = peg$f537(s1, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -53798,7 +63319,7 @@ function peg$parse(input, options) {
   function peg$parseDistinctClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 260;
+    const key = peg$currPos * 508 + 302;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -53812,11 +63333,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       s3 = input.substr(peg$currPos, 2);
-      if (s3.toLowerCase() === peg$c103) {
+      if (s3.toLowerCase() === peg$c94) {
         peg$currPos += (2);
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e108); }
+        if (peg$silentFails === 0) { peg$fail(peg$e99); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$currPos;
@@ -53838,11 +63359,11 @@ function peg$parse(input, options) {
         if (s4 !== peg$FAILED) {
           s5 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 40) {
-            s6 = peg$c21;
+            s6 = peg$c25;
             peg$currPos++;
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
@@ -53850,15 +63371,15 @@ function peg$parse(input, options) {
             if (s8 !== peg$FAILED) {
               s9 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s10 = peg$c22;
+                s10 = peg$c26;
                 peg$currPos++;
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s10 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f430(s8);
+                s0 = peg$f538(s8);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -53888,7 +63409,7 @@ function peg$parse(input, options) {
       s1 = peg$parseKW_DISTINCT();
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f431();
+        s1 = peg$f539();
       }
       s0 = s1;
       if (s0 === peg$FAILED) {
@@ -53896,7 +63417,7 @@ function peg$parse(input, options) {
         s1 = peg$parseKW_ALL();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f432();
+          s1 = peg$f540();
         }
         s0 = s1;
       }
@@ -53910,7 +63431,7 @@ function peg$parse(input, options) {
   function peg$parseCTEClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;
 
-    const key = peg$currPos * 466 + 261;
+    const key = peg$currPos * 508 + 303;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -53924,11 +63445,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s3 = peg$c21;
+        s3 = peg$c25;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -53936,11 +63457,11 @@ function peg$parse(input, options) {
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s7 = peg$c15;
+            s7 = peg$c24;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$parse_();
@@ -53950,11 +63471,11 @@ function peg$parse(input, options) {
               s11 = peg$currPos;
               s12 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s13 = peg$c15;
+                s13 = peg$c24;
                 peg$currPos++;
               } else {
                 s13 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s13 !== peg$FAILED) {
                 s14 = peg$parse_();
@@ -53975,11 +63496,11 @@ function peg$parse(input, options) {
                 s11 = peg$currPos;
                 s12 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s13 = peg$c15;
+                  s13 = peg$c24;
                   peg$currPos++;
                 } else {
                   s13 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s13 !== peg$FAILED) {
                   s14 = peg$parse_();
@@ -53998,15 +63519,15 @@ function peg$parse(input, options) {
               }
               s11 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s12 = peg$c22;
+                s12 = peg$c26;
                 peg$currPos++;
               } else {
                 s12 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s12 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f433(s2, s5, s9, s10);
+                s0 = peg$f541(s2, s5, s9, s10);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -54037,11 +63558,11 @@ function peg$parse(input, options) {
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         s3 = input.substr(peg$currPos, 9);
-        if (s3.toLowerCase() === peg$c240) {
+        if (s3.toLowerCase() === peg$c271) {
           peg$currPos += (9);
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e254); }
+          if (peg$silentFails === 0) { peg$fail(peg$e287); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$currPos;
@@ -54065,7 +63586,7 @@ function peg$parse(input, options) {
             s6 = peg$parseCTEItemList();
             if (s6 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f434(s2, s6);
+              s0 = peg$f542(s2, s6);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -54090,7 +63611,7 @@ function peg$parse(input, options) {
           s3 = peg$parseCTEItemList();
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f435(s2, s3);
+            s0 = peg$f543(s2, s3);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -54110,7 +63631,7 @@ function peg$parse(input, options) {
   function peg$parseTupleCTEElement() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 262;
+    const key = peg$currPos * 508 + 304;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -54129,7 +63650,7 @@ function peg$parse(input, options) {
         s5 = peg$parseAliasName();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f436(s1, s2, s5);
+          s0 = peg$f544(s1, s2, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -54151,7 +63672,7 @@ function peg$parse(input, options) {
   function peg$parseCTEItemList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 263;
+    const key = peg$currPos * 508 + 305;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -54167,11 +63688,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -54192,11 +63713,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -54215,7 +63736,7 @@ function peg$parse(input, options) {
       }
       s3 = peg$parse_HWS();
       peg$savedPos = s0;
-      s0 = peg$f437(s1, s2, s3);
+      s0 = peg$f545(s1, s2, s3);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -54229,7 +63750,7 @@ function peg$parse(input, options) {
   function peg$parseCTEItem() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 264;
+    const key = peg$currPos * 508 + 306;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -54243,11 +63764,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s3 = peg$c21;
+        s3 = peg$c25;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -54257,11 +63778,11 @@ function peg$parse(input, options) {
           s7 = peg$currPos;
           s8 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s9 = peg$c15;
+            s9 = peg$c24;
             peg$currPos++;
           } else {
             s9 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s9 !== peg$FAILED) {
             s10 = peg$parse_();
@@ -54282,11 +63803,11 @@ function peg$parse(input, options) {
             s7 = peg$currPos;
             s8 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 44) {
-              s9 = peg$c15;
+              s9 = peg$c24;
               peg$currPos++;
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e17); }
+              if (peg$silentFails === 0) { peg$fail(peg$e28); }
             }
             if (s9 !== peg$FAILED) {
               s10 = peg$parse_();
@@ -54305,11 +63826,11 @@ function peg$parse(input, options) {
           }
           s7 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 41) {
-            s8 = peg$c22;
+            s8 = peg$c26;
             peg$currPos++;
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e26); }
+            if (peg$silentFails === 0) { peg$fail(peg$e30); }
           }
           if (s8 !== peg$FAILED) {
             s9 = peg$parse_();
@@ -54317,11 +63838,11 @@ function peg$parse(input, options) {
             if (s10 !== peg$FAILED) {
               s11 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 40) {
-                s12 = peg$c21;
+                s12 = peg$c25;
                 peg$currPos++;
               } else {
                 s12 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                if (peg$silentFails === 0) { peg$fail(peg$e29); }
               }
               if (s12 !== peg$FAILED) {
                 s13 = peg$parse_();
@@ -54329,15 +63850,15 @@ function peg$parse(input, options) {
                 if (s14 !== peg$FAILED) {
                   s15 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 41) {
-                    s16 = peg$c22;
+                    s16 = peg$c26;
                     peg$currPos++;
                   } else {
                     s16 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
                   }
                   if (s16 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f438(s1, s5, s6, s13, s14, s15);
+                    s0 = peg$f546(s1, s5, s6, s13, s14, s15);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -54379,11 +63900,11 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 40) {
-            s5 = peg$c21;
+            s5 = peg$c25;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
@@ -54391,15 +63912,15 @@ function peg$parse(input, options) {
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s9 = peg$c22;
+                s9 = peg$c26;
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s9 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f439(s1, s6, s7, s8);
+                s0 = peg$f547(s1, s6, s7, s8);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -54423,11 +63944,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 40) {
-          s1 = peg$c21;
+          s1 = peg$c25;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$parse_();
@@ -54437,11 +63958,11 @@ function peg$parse(input, options) {
             s5 = peg$currPos;
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 44) {
-              s7 = peg$c15;
+              s7 = peg$c24;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e17); }
+              if (peg$silentFails === 0) { peg$fail(peg$e28); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
@@ -54462,11 +63983,11 @@ function peg$parse(input, options) {
               s5 = peg$currPos;
               s6 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s7 = peg$c15;
+                s7 = peg$c24;
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s7 !== peg$FAILED) {
                 s8 = peg$parse_();
@@ -54485,20 +64006,20 @@ function peg$parse(input, options) {
             }
             s5 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s6 = peg$c22;
+              s6 = peg$c26;
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$parse_();
-              if (input.substr(peg$currPos, 2) === peg$c241) {
-                s8 = peg$c241;
+              if (input.substr(peg$currPos, 2) === peg$c272) {
+                s8 = peg$c272;
                 peg$currPos += 2;
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e255); }
+                if (peg$silentFails === 0) { peg$fail(peg$e288); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$parse_();
@@ -54511,7 +64032,7 @@ function peg$parse(input, options) {
                     s14 = peg$parseAliasName();
                     if (s14 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f440(s3, s4, s10, s11, s14);
+                      s0 = peg$f548(s3, s4, s10, s11, s14);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -54545,12 +64066,12 @@ function peg$parse(input, options) {
           s1 = peg$parseLambdaParamName();
           if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
-            if (input.substr(peg$currPos, 2) === peg$c241) {
-              s3 = peg$c241;
+            if (input.substr(peg$currPos, 2) === peg$c272) {
+              s3 = peg$c272;
               peg$currPos += 2;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e255); }
+              if (peg$silentFails === 0) { peg$fail(peg$e288); }
             }
             if (s3 !== peg$FAILED) {
               s4 = peg$parse_();
@@ -54563,7 +64084,7 @@ function peg$parse(input, options) {
                   s9 = peg$parseAliasName();
                   if (s9 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f441(s1, s5, s6, s9);
+                    s0 = peg$f549(s1, s5, s6, s9);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -54595,7 +64116,7 @@ function peg$parse(input, options) {
                 s5 = peg$parseAliasName();
                 if (s5 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f442(s1, s2, s5);
+                  s0 = peg$f550(s1, s2, s5);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -54613,7 +64134,7 @@ function peg$parse(input, options) {
               s1 = peg$parseTernaryExpr();
               if (s1 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s1 = peg$f443(s1);
+                s1 = peg$f551(s1);
               }
               s0 = s1;
             }
@@ -54630,7 +64151,7 @@ function peg$parse(input, options) {
   function peg$parseSelectItemList() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 265;
+    const key = peg$currPos * 508 + 307;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -54646,11 +64167,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -54686,11 +64207,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -54725,11 +64246,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -54743,7 +64264,7 @@ function peg$parse(input, options) {
         s3 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f444(s1, s2);
+      s0 = peg$f552(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -54757,7 +64278,7 @@ function peg$parse(input, options) {
   function peg$parseSelectClauseKeyword() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 266;
+    const key = peg$currPos * 508 + 308;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -54768,11 +64289,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c69) {
+    if (s1.toLowerCase() === peg$c73) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e74); }
+      if (peg$silentFails === 0) { peg$fail(peg$e78); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -54796,20 +64317,20 @@ function peg$parse(input, options) {
         s4 = peg$currPos;
         peg$silentFails++;
         s5 = input.charAt(peg$currPos);
-        if (peg$r13.test(s5)) {
+        if (peg$r15.test(s5)) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e256); }
+          if (peg$silentFails === 0) { peg$fail(peg$e289); }
         }
         if (s5 === peg$FAILED) {
           s5 = peg$currPos;
           s6 = input.substr(peg$currPos, 2);
-          if (s6.toLowerCase() === peg$c89) {
+          if (s6.toLowerCase() === peg$c93) {
             peg$currPos += (2);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e94); }
+            if (peg$silentFails === 0) { peg$fail(peg$e98); }
           }
           if (s6 !== peg$FAILED) {
             s7 = peg$currPos;
@@ -54842,11 +64363,11 @@ function peg$parse(input, options) {
           if (s5 === peg$FAILED) {
             s5 = peg$currPos;
             s6 = input.substr(peg$currPos, 3);
-            if (s6.toLowerCase() === peg$c145) {
+            if (s6.toLowerCase() === peg$c189) {
               peg$currPos += (3);
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e151); }
+              if (peg$silentFails === 0) { peg$fail(peg$e198); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$currPos;
@@ -54879,11 +64400,11 @@ function peg$parse(input, options) {
             if (s5 === peg$FAILED) {
               s5 = peg$currPos;
               s6 = input.substr(peg$currPos, 2);
-              if (s6.toLowerCase() === peg$c149) {
+              if (s6.toLowerCase() === peg$c193) {
                 peg$currPos += (2);
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e155); }
+                if (peg$silentFails === 0) { peg$fail(peg$e202); }
               }
               if (s6 !== peg$FAILED) {
                 s7 = peg$currPos;
@@ -54941,75 +64462,75 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c61) {
+      if (s1.toLowerCase() === peg$c65) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e66); }
+        if (peg$silentFails === 0) { peg$fail(peg$e70); }
       }
       if (s1 === peg$FAILED) {
         s1 = input.substr(peg$currPos, 8);
-        if (s1.toLowerCase() === peg$c242) {
+        if (s1.toLowerCase() === peg$c273) {
           peg$currPos += (8);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e257); }
+          if (peg$silentFails === 0) { peg$fail(peg$e290); }
         }
         if (s1 === peg$FAILED) {
           s1 = input.substr(peg$currPos, 5);
-          if (s1.toLowerCase() === peg$c226) {
+          if (s1.toLowerCase() === peg$c258) {
             peg$currPos += (5);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e240); }
+            if (peg$silentFails === 0) { peg$fail(peg$e274); }
           }
           if (s1 === peg$FAILED) {
             s1 = input.substr(peg$currPos, 6);
-            if (s1.toLowerCase() === peg$c243) {
+            if (s1.toLowerCase() === peg$c274) {
               peg$currPos += (6);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e258); }
+              if (peg$silentFails === 0) { peg$fail(peg$e291); }
             }
             if (s1 === peg$FAILED) {
               s1 = input.substr(peg$currPos, 5);
-              if (s1.toLowerCase() === peg$c79) {
+              if (s1.toLowerCase() === peg$c83) {
                 peg$currPos += (5);
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e84); }
+                if (peg$silentFails === 0) { peg$fail(peg$e88); }
               }
               if (s1 === peg$FAILED) {
                 s1 = input.substr(peg$currPos, 5);
-                if (s1.toLowerCase() === peg$c244) {
+                if (s1.toLowerCase() === peg$c152) {
                   peg$currPos += (5);
                 } else {
                   s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e259); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e161); }
                 }
                 if (s1 === peg$FAILED) {
                   s1 = input.substr(peg$currPos, 6);
-                  if (s1.toLowerCase() === peg$c245) {
+                  if (s1.toLowerCase() === peg$c275) {
                     peg$currPos += (6);
                   } else {
                     s1 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e260); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e292); }
                   }
                   if (s1 === peg$FAILED) {
                     s1 = input.substr(peg$currPos, 5);
-                    if (s1.toLowerCase() === peg$c246) {
+                    if (s1.toLowerCase() === peg$c276) {
                       peg$currPos += (5);
                     } else {
                       s1 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e261); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e293); }
                     }
                     if (s1 === peg$FAILED) {
                       s1 = input.substr(peg$currPos, 9);
-                      if (s1.toLowerCase() === peg$c236) {
+                      if (s1.toLowerCase() === peg$c267) {
                         peg$currPos += (9);
                       } else {
                         s1 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e250); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e283); }
                       }
                       if (s1 === peg$FAILED) {
                         s1 = input.substr(peg$currPos, 4);
@@ -55021,11 +64542,11 @@ function peg$parse(input, options) {
                         }
                         if (s1 === peg$FAILED) {
                           s1 = input.substr(peg$currPos, 5);
-                          if (s1.toLowerCase() === peg$c75) {
+                          if (s1.toLowerCase() === peg$c79) {
                             peg$currPos += (5);
                           } else {
                             s1 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e80); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e84); }
                           }
                         }
                       }
@@ -55075,7 +64596,7 @@ function peg$parse(input, options) {
   function peg$parseSelectItem() {
     let s0, s1, s2;
 
-    const key = peg$currPos * 466 + 267;
+    const key = peg$currPos * 508 + 309;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -55092,7 +64613,7 @@ function peg$parse(input, options) {
         s2 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f445(s1, s2);
+      s0 = peg$f553(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -55106,7 +64627,7 @@ function peg$parse(input, options) {
   function peg$parseSelectItemAlias() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 268;
+    const key = peg$currPos * 508 + 310;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -55123,7 +64644,7 @@ function peg$parse(input, options) {
       s4 = peg$parseAliasName();
       if (s4 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f446(s4);
+        s0 = peg$f554(s4);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -55150,11 +64671,11 @@ function peg$parse(input, options) {
         peg$silentFails++;
         s4 = peg$currPos;
         s5 = input.substr(peg$currPos, 8);
-        if (s5.toLowerCase() === peg$c121) {
+        if (s5.toLowerCase() === peg$c178) {
           peg$currPos += (8);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e127); }
+          if (peg$silentFails === 0) { peg$fail(peg$e187); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -55176,11 +64697,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 4);
-            if (s8.toLowerCase() === peg$c53) {
+            if (s8.toLowerCase() === peg$c57) {
               peg$currPos += (4);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e58); }
+              if (peg$silentFails === 0) { peg$fail(peg$e62); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -55229,7 +64750,7 @@ function peg$parse(input, options) {
           s4 = peg$parseIdentifier();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f447(s4);
+            s0 = peg$f555(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -55252,7 +64773,7 @@ function peg$parse(input, options) {
   function peg$parseFromClause() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 269;
+    const key = peg$currPos * 508 + 311;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -55268,7 +64789,7 @@ function peg$parse(input, options) {
       s3 = peg$parseJoinExpr();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f448(s2, s3);
+        s0 = peg$f556(s2, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -55286,7 +64807,7 @@ function peg$parse(input, options) {
   function peg$parseJoinExpr() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 270;
+    const key = peg$currPos * 508 + 312;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -55323,7 +64844,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f449(s1, s2);
+      s0 = peg$f557(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -55337,7 +64858,7 @@ function peg$parse(input, options) {
   function peg$parseFromAtom() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 271;
+    const key = peg$currPos * 508 + 313;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -55348,11 +64869,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
@@ -55360,11 +64881,11 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s5 = peg$c22;
+          s5 = peg$c26;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parseFromAtomAlias();
@@ -55398,7 +64919,7 @@ function peg$parse(input, options) {
             s8 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f450(s2, s3, s4, s6, s7, s8);
+          s0 = peg$f558(s2, s3, s4, s6, s7, s8);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -55446,7 +64967,7 @@ function peg$parse(input, options) {
           s4 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f451(s1, s2, s3, s4);
+        s0 = peg$f559(s1, s2, s3, s4);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -55486,7 +65007,7 @@ function peg$parse(input, options) {
             s4 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f452(s1, s2, s3, s4);
+          s0 = peg$f560(s1, s2, s3, s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -55502,7 +65023,7 @@ function peg$parse(input, options) {
   function peg$parseSampleClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 272;
+    const key = peg$currPos * 508 + 314;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -55513,11 +65034,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c81) {
+    if (s1.toLowerCase() === peg$c85) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e86); }
+      if (peg$silentFails === 0) { peg$fail(peg$e90); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -55543,11 +65064,11 @@ function peg$parse(input, options) {
           s5 = peg$currPos;
           s6 = peg$parse_();
           s7 = input.substr(peg$currPos, 6);
-          if (s7.toLowerCase() === peg$c245) {
+          if (s7.toLowerCase() === peg$c275) {
             peg$currPos += (6);
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e260); }
+            if (peg$silentFails === 0) { peg$fail(peg$e292); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$currPos;
@@ -55588,7 +65109,7 @@ function peg$parse(input, options) {
             s5 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f453(s4, s5);
+          s0 = peg$f561(s4, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -55610,7 +65131,7 @@ function peg$parse(input, options) {
   function peg$parseSampleRatioExpr() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 273;
+    const key = peg$currPos * 508 + 315;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -55624,18 +65145,18 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 47) {
-        s3 = peg$c247;
+        s3 = peg$c277;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e262); }
+        if (peg$silentFails === 0) { peg$fail(peg$e294); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$parseSampleNumber();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f454(s1, s5);
+          s0 = peg$f562(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -55653,7 +65174,7 @@ function peg$parse(input, options) {
       s1 = peg$parseSampleNumber();
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f455(s1);
+        s1 = peg$f563(s1);
       }
       s0 = s1;
     }
@@ -55666,7 +65187,7 @@ function peg$parse(input, options) {
   function peg$parseSampleNumber() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 274;
+    const key = peg$currPos * 508 + 316;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -55688,20 +65209,20 @@ function peg$parse(input, options) {
     if (s3 !== peg$FAILED) {
       s4 = [];
       s5 = input.charAt(peg$currPos);
-      if (peg$r14.test(s5)) {
+      if (peg$r16.test(s5)) {
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e263); }
+        if (peg$silentFails === 0) { peg$fail(peg$e295); }
       }
       while (s5 !== peg$FAILED) {
         s4.push(s5);
         s5 = input.charAt(peg$currPos);
-        if (peg$r14.test(s5)) {
+        if (peg$r16.test(s5)) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e263); }
+          if (peg$silentFails === 0) { peg$fail(peg$e295); }
         }
       }
       s3 = [s3, s4];
@@ -55717,30 +65238,30 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       if (input.charCodeAt(peg$currPos) === 46) {
-        s2 = peg$c35;
+        s2 = peg$c39;
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
         s4 = [];
         s5 = input.charAt(peg$currPos);
-        if (peg$r14.test(s5)) {
+        if (peg$r16.test(s5)) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e263); }
+          if (peg$silentFails === 0) { peg$fail(peg$e295); }
         }
         while (s5 !== peg$FAILED) {
           s4.push(s5);
           s5 = input.charAt(peg$currPos);
-          if (peg$r14.test(s5)) {
+          if (peg$r16.test(s5)) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e263); }
+            if (peg$silentFails === 0) { peg$fail(peg$e295); }
           }
         }
         s3 = input.substring(s3, peg$currPos);
@@ -55749,7 +65270,7 @@ function peg$parse(input, options) {
           s4 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f456(s1, s3, s4);
+        s0 = peg$f564(s1, s3, s4);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -55761,31 +65282,31 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 46) {
-        s1 = peg$c35;
+        s1 = peg$c39;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
         s3 = [];
         s4 = input.charAt(peg$currPos);
-        if (peg$r14.test(s4)) {
+        if (peg$r16.test(s4)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e263); }
+          if (peg$silentFails === 0) { peg$fail(peg$e295); }
         }
         if (s4 !== peg$FAILED) {
           while (s4 !== peg$FAILED) {
             s3.push(s4);
             s4 = input.charAt(peg$currPos);
-            if (peg$r14.test(s4)) {
+            if (peg$r16.test(s4)) {
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e263); }
+              if (peg$silentFails === 0) { peg$fail(peg$e295); }
             }
           }
         } else {
@@ -55802,7 +65323,7 @@ function peg$parse(input, options) {
             s3 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f457(s2, s3);
+          s0 = peg$f565(s2, s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -55825,20 +65346,20 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = [];
           s5 = input.charAt(peg$currPos);
-          if (peg$r14.test(s5)) {
+          if (peg$r16.test(s5)) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e263); }
+            if (peg$silentFails === 0) { peg$fail(peg$e295); }
           }
           while (s5 !== peg$FAILED) {
             s4.push(s5);
             s5 = input.charAt(peg$currPos);
-            if (peg$r14.test(s5)) {
+            if (peg$r16.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e263); }
+              if (peg$silentFails === 0) { peg$fail(peg$e295); }
             }
           }
           s3 = [s3, s4];
@@ -55856,7 +65377,7 @@ function peg$parse(input, options) {
           s2 = peg$parseSampleExponent();
           if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f458(s1, s2);
+            s0 = peg$f566(s1, s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -55879,20 +65400,20 @@ function peg$parse(input, options) {
           if (s3 !== peg$FAILED) {
             s4 = [];
             s5 = input.charAt(peg$currPos);
-            if (peg$r14.test(s5)) {
+            if (peg$r16.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e263); }
+              if (peg$silentFails === 0) { peg$fail(peg$e295); }
             }
             while (s5 !== peg$FAILED) {
               s4.push(s5);
               s5 = input.charAt(peg$currPos);
-              if (peg$r14.test(s5)) {
+              if (peg$r16.test(s5)) {
                 peg$currPos++;
               } else {
                 s5 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e263); }
+                if (peg$silentFails === 0) { peg$fail(peg$e295); }
               }
             }
             s3 = [s3, s4];
@@ -55908,7 +65429,7 @@ function peg$parse(input, options) {
           }
           if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
-            s1 = peg$f459(s1);
+            s1 = peg$f567(s1);
           }
           s0 = s1;
         }
@@ -55923,7 +65444,7 @@ function peg$parse(input, options) {
   function peg$parseSampleExponent() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 275;
+    const key = peg$currPos * 508 + 317;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -55934,20 +65455,20 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.charAt(peg$currPos);
-    if (peg$r15.test(s1)) {
+    if (peg$r17.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e264); }
+      if (peg$silentFails === 0) { peg$fail(peg$e296); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
       s3 = input.charAt(peg$currPos);
-      if (peg$r16.test(s3)) {
+      if (peg$r18.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e265); }
+        if (peg$silentFails === 0) { peg$fail(peg$e297); }
       }
       if (s3 === peg$FAILED) {
         s3 = null;
@@ -55983,7 +65504,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f460(s1, s2, s3);
+        s0 = peg$f568(s1, s2, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -56001,7 +65522,7 @@ function peg$parse(input, options) {
   function peg$parseFromAtomAlias() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;
 
-    const key = peg$currPos * 466 + 276;
+    const key = peg$currPos * 508 + 318;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -56020,11 +65541,11 @@ function peg$parse(input, options) {
         s5 = peg$currPos;
         s6 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s7 = peg$c21;
+          s7 = peg$c25;
           peg$currPos++;
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s7 !== peg$FAILED) {
           s8 = peg$parse_();
@@ -56034,11 +65555,11 @@ function peg$parse(input, options) {
             s11 = peg$currPos;
             s12 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 44) {
-              s13 = peg$c15;
+              s13 = peg$c24;
               peg$currPos++;
             } else {
               s13 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e17); }
+              if (peg$silentFails === 0) { peg$fail(peg$e28); }
             }
             if (s13 !== peg$FAILED) {
               s14 = peg$parse_();
@@ -56059,11 +65580,11 @@ function peg$parse(input, options) {
               s11 = peg$currPos;
               s12 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s13 = peg$c15;
+                s13 = peg$c24;
                 peg$currPos++;
               } else {
                 s13 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s13 !== peg$FAILED) {
                 s14 = peg$parse_();
@@ -56082,15 +65603,15 @@ function peg$parse(input, options) {
             }
             s11 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s12 = peg$c22;
+              s12 = peg$c26;
               peg$currPos++;
             } else {
               s12 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s12 !== peg$FAILED) {
               peg$savedPos = s5;
-              s5 = peg$f461(s4, s9, s10);
+              s5 = peg$f569(s4, s9, s10);
             } else {
               peg$currPos = s5;
               s5 = peg$FAILED;
@@ -56107,7 +65628,7 @@ function peg$parse(input, options) {
           s5 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f462(s4, s5);
+        s0 = peg$f570(s4, s5);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -56120,11 +65641,11 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s1 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s2 = peg$c21;
+        s2 = peg$c25;
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
@@ -56136,11 +65657,11 @@ function peg$parse(input, options) {
           if (s5 === peg$FAILED) {
             s5 = peg$currPos;
             s6 = input.substr(peg$currPos, 7);
-            if (s6.toLowerCase() === peg$c227) {
+            if (s6.toLowerCase() === peg$c259) {
               peg$currPos += (7);
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e241); }
+              if (peg$silentFails === 0) { peg$fail(peg$e275); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$currPos;
@@ -56186,11 +65707,11 @@ function peg$parse(input, options) {
             s7 = peg$currPos;
             s8 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 44) {
-              s9 = peg$c15;
+              s9 = peg$c24;
               peg$currPos++;
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e17); }
+              if (peg$silentFails === 0) { peg$fail(peg$e28); }
             }
             if (s9 !== peg$FAILED) {
               s10 = peg$parse_();
@@ -56211,11 +65732,11 @@ function peg$parse(input, options) {
               s7 = peg$currPos;
               s8 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s9 = peg$c15;
+                s9 = peg$c24;
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
@@ -56234,15 +65755,15 @@ function peg$parse(input, options) {
             }
             s7 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s8 = peg$c22;
+              s8 = peg$c26;
               peg$currPos++;
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s8 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f463(s5, s6);
+              s0 = peg$f571(s5, s6);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -56299,11 +65820,11 @@ function peg$parse(input, options) {
               peg$silentFails++;
               s6 = peg$currPos;
               s7 = input.substr(peg$currPos, 8);
-              if (s7.toLowerCase() === peg$c121) {
+              if (s7.toLowerCase() === peg$c178) {
                 peg$currPos += (8);
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e127); }
+                if (peg$silentFails === 0) { peg$fail(peg$e187); }
               }
               if (s7 !== peg$FAILED) {
                 s8 = peg$currPos;
@@ -56325,11 +65846,11 @@ function peg$parse(input, options) {
                 if (s8 !== peg$FAILED) {
                   s9 = peg$parse_();
                   s10 = input.substr(peg$currPos, 4);
-                  if (s10.toLowerCase() === peg$c53) {
+                  if (s10.toLowerCase() === peg$c57) {
                     peg$currPos += (4);
                   } else {
                     s10 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e58); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e62); }
                   }
                   if (s10 !== peg$FAILED) {
                     s11 = peg$currPos;
@@ -56378,7 +65899,7 @@ function peg$parse(input, options) {
                 s6 = peg$parseIdentifier();
                 if (s6 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f464(s6);
+                  s0 = peg$f572(s6);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -56410,7 +65931,7 @@ function peg$parse(input, options) {
   function peg$parseTableFunctionRef() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 277;
+    const key = peg$currPos * 508 + 319;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -56424,11 +65945,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s3 = peg$c21;
+        s3 = peg$c25;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -56440,11 +65961,11 @@ function peg$parse(input, options) {
         s7 = peg$currPos;
         s8 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s9 = peg$c15;
+          s9 = peg$c24;
           peg$currPos++;
         } else {
           s9 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s9 !== peg$FAILED) {
           s8 = [s8, s9];
@@ -56477,15 +65998,15 @@ function peg$parse(input, options) {
         }
         s7 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s8 = peg$c22;
+          s8 = peg$c26;
           peg$currPos++;
         } else {
           s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s8 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f465(s1, s5, s6);
+          s0 = peg$f573(s1, s5, s6);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -56507,7 +66028,7 @@ function peg$parse(input, options) {
   function peg$parseTableFunctionArgList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 278;
+    const key = peg$currPos * 508 + 320;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -56523,11 +66044,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -56548,11 +66069,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -56570,7 +66091,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f466(s1, s2);
+      s0 = peg$f574(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -56584,7 +66105,7 @@ function peg$parse(input, options) {
   function peg$parseJoinPart() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 279;
+    const key = peg$currPos * 508 + 321;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -56610,7 +66131,7 @@ function peg$parse(input, options) {
         s2 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f467(s1, s2);
+      s0 = peg$f575(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -56626,7 +66147,7 @@ function peg$parse(input, options) {
           s5 = peg$parseJoinConstraint();
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f468(s1, s3, s5);
+            s0 = peg$f576(s1, s3, s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -56647,7 +66168,7 @@ function peg$parse(input, options) {
           s3 = peg$parseFromAtom();
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f469(s1, s3);
+            s0 = peg$f577(s1, s3);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -56659,18 +66180,18 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 44) {
-            s1 = peg$c15;
+            s1 = peg$c24;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
             s3 = peg$parseFromAtom();
             if (s3 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f470(s3);
+              s0 = peg$f578(s3);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -56691,7 +66212,7 @@ function peg$parse(input, options) {
   function peg$parseJoinKeyword() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 280;
+    const key = peg$currPos * 508 + 322;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -56710,11 +66231,11 @@ function peg$parse(input, options) {
     }
     s2 = peg$parse_();
     s3 = input.substr(peg$currPos, 5);
-    if (s3.toLowerCase() === peg$c248) {
+    if (s3.toLowerCase() === peg$c278) {
       peg$currPos += (5);
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e266); }
+      if (peg$silentFails === 0) { peg$fail(peg$e298); }
     }
     if (s3 !== peg$FAILED) {
       s4 = peg$currPos;
@@ -56738,7 +66259,7 @@ function peg$parse(input, options) {
         s6 = peg$parseKW_JOIN();
         if (s6 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f471();
+          s0 = peg$f579();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -56783,7 +66304,7 @@ function peg$parse(input, options) {
       s4 = peg$parseKW_CROSS();
       if (s4 !== peg$FAILED) {
         peg$savedPos = s3;
-        s4 = peg$f472();
+        s4 = peg$f580();
       }
       s3 = s4;
       if (s3 === peg$FAILED) {
@@ -56791,7 +66312,7 @@ function peg$parse(input, options) {
         s4 = peg$parseKW_FULL();
         if (s4 !== peg$FAILED) {
           peg$savedPos = s3;
-          s4 = peg$f473();
+          s4 = peg$f581();
         }
         s3 = s4;
         if (s3 === peg$FAILED) {
@@ -56799,7 +66320,7 @@ function peg$parse(input, options) {
           s4 = peg$parseKW_LEFT();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s3;
-            s4 = peg$f474();
+            s4 = peg$f582();
           }
           s3 = s4;
           if (s3 === peg$FAILED) {
@@ -56807,7 +66328,7 @@ function peg$parse(input, options) {
             s4 = peg$parseKW_RIGHT();
             if (s4 !== peg$FAILED) {
               peg$savedPos = s3;
-              s4 = peg$f475();
+              s4 = peg$f583();
             }
             s3 = s4;
             if (s3 === peg$FAILED) {
@@ -56815,7 +66336,7 @@ function peg$parse(input, options) {
               s4 = peg$parseKW_INNER();
               if (s4 !== peg$FAILED) {
                 peg$savedPos = s3;
-                s4 = peg$f476();
+                s4 = peg$f584();
               }
               s3 = s4;
             }
@@ -56855,7 +66376,7 @@ function peg$parse(input, options) {
       s7 = peg$parseKW_JOIN();
       if (s7 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f477(s3);
+        s0 = peg$f585(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -56870,7 +66391,7 @@ function peg$parse(input, options) {
   function peg$parseJoinStrictness() {
     let s0;
 
-    const key = peg$currPos * 466 + 281;
+    const key = peg$currPos * 508 + 323;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -56901,7 +66422,7 @@ function peg$parse(input, options) {
   function peg$parseArrayJoinKeyword() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 282;
+    const key = peg$currPos * 508 + 324;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -56920,7 +66441,7 @@ function peg$parse(input, options) {
         s5 = peg$parseKW_JOIN();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f478();
+          s0 = peg$f586();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -56941,7 +66462,7 @@ function peg$parse(input, options) {
         s3 = peg$parseKW_JOIN();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f479();
+          s0 = peg$f587();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -56960,7 +66481,7 @@ function peg$parse(input, options) {
   function peg$parseJoinConstraint() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 283;
+    const key = peg$currPos * 508 + 325;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -56976,7 +66497,7 @@ function peg$parse(input, options) {
       s3 = peg$parseExpression();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f480(s2, s3);
+        s0 = peg$f588(s2, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -56991,11 +66512,11 @@ function peg$parse(input, options) {
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s3 = peg$c21;
+          s3 = peg$c25;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
@@ -57005,15 +66526,15 @@ function peg$parse(input, options) {
           }
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 41) {
-            s7 = peg$c22;
+            s7 = peg$c26;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e26); }
+            if (peg$silentFails === 0) { peg$fail(peg$e30); }
           }
           if (s7 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f481(s5);
+            s0 = peg$f589(s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -57032,15 +66553,15 @@ function peg$parse(input, options) {
         if (s1 !== peg$FAILED) {
           s2 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 42) {
-            s3 = peg$c185;
+            s3 = peg$c123;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e195); }
+            if (peg$silentFails === 0) { peg$fail(peg$e130); }
           }
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f482();
+            s0 = peg$f590();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -57057,7 +66578,7 @@ function peg$parse(input, options) {
             s3 = peg$parseIdentifierList();
             if (s3 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f483(s3);
+              s0 = peg$f591(s3);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -57078,7 +66599,7 @@ function peg$parse(input, options) {
   function peg$parseUsingColumnList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 284;
+    const key = peg$currPos * 508 + 326;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -57094,11 +66615,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -57119,11 +66640,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -57141,7 +66662,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f484(s1, s2);
+      s0 = peg$f592(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -57155,7 +66676,7 @@ function peg$parse(input, options) {
   function peg$parseUsingColumn() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 285;
+    const key = peg$currPos * 508 + 327;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -57174,7 +66695,7 @@ function peg$parse(input, options) {
         s5 = peg$parseAliasName();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f485(s1, s5);
+          s0 = peg$f593(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -57192,7 +66713,7 @@ function peg$parse(input, options) {
       s1 = peg$parseIdentifier();
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f486(s1);
+        s1 = peg$f594(s1);
       }
       s0 = s1;
     }
@@ -57205,7 +66726,7 @@ function peg$parse(input, options) {
   function peg$parseIdentifierList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 286;
+    const key = peg$currPos * 508 + 328;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -57221,11 +66742,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -57246,11 +66767,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -57268,7 +66789,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f487(s1, s2);
+      s0 = peg$f595(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -57282,7 +66803,7 @@ function peg$parse(input, options) {
   function peg$parsePrewhereClause() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 287;
+    const key = peg$currPos * 508 + 329;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -57298,7 +66819,7 @@ function peg$parse(input, options) {
       s3 = peg$parseExpression();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f488(s2, s3);
+        s0 = peg$f596(s2, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -57316,7 +66837,7 @@ function peg$parse(input, options) {
   function peg$parseWhereClause() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 288;
+    const key = peg$currPos * 508 + 330;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -57332,7 +66853,7 @@ function peg$parse(input, options) {
       s3 = peg$parseExpression();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f489(s2, s3);
+        s0 = peg$f597(s2, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -57350,7 +66871,7 @@ function peg$parse(input, options) {
   function peg$parseGroupByClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
 
-    const key = peg$currPos * 466 + 289;
+    const key = peg$currPos * 508 + 331;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -57375,7 +66896,7 @@ function peg$parse(input, options) {
             s7 = peg$parseGroupByModifier();
           }
           peg$savedPos = s0;
-          s0 = peg$f490(s6);
+          s0 = peg$f598(s6);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -57397,11 +66918,11 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           s5 = input.substr(peg$currPos, 8);
-          if (s5.toLowerCase() === peg$c249) {
+          if (s5.toLowerCase() === peg$c279) {
             peg$currPos += (8);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e267); }
+            if (peg$silentFails === 0) { peg$fail(peg$e299); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$currPos;
@@ -57423,11 +66944,11 @@ function peg$parse(input, options) {
             if (s6 !== peg$FAILED) {
               s7 = peg$parse_();
               s8 = input.substr(peg$currPos, 4);
-              if (s8.toLowerCase() === peg$c250) {
+              if (s8.toLowerCase() === peg$c280) {
                 peg$currPos += (4);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e268); }
+                if (peg$silentFails === 0) { peg$fail(peg$e300); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -57449,11 +66970,11 @@ function peg$parse(input, options) {
                 if (s9 !== peg$FAILED) {
                   s10 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 40) {
-                    s11 = peg$c21;
+                    s11 = peg$c25;
                     peg$currPos++;
                   } else {
                     s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e29); }
                   }
                   if (s11 !== peg$FAILED) {
                     s12 = peg$parse_();
@@ -57461,11 +66982,11 @@ function peg$parse(input, options) {
                     if (s13 !== peg$FAILED) {
                       s14 = peg$parse_();
                       if (input.charCodeAt(peg$currPos) === 41) {
-                        s15 = peg$c22;
+                        s15 = peg$c26;
                         peg$currPos++;
                       } else {
                         s15 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e30); }
                       }
                       if (s15 !== peg$FAILED) {
                         s16 = [];
@@ -57475,7 +66996,7 @@ function peg$parse(input, options) {
                           s17 = peg$parseGroupByModifier();
                         }
                         peg$savedPos = s0;
-                        s0 = peg$f491(s13, s16);
+                        s0 = peg$f599(s13, s16);
                       } else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
@@ -57529,7 +67050,7 @@ function peg$parse(input, options) {
                 s7 = peg$parseGroupByModifier();
               }
               peg$savedPos = s0;
-              s0 = peg$f492(s4, s5, s6);
+              s0 = peg$f600(s4, s5, s6);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -57553,7 +67074,7 @@ function peg$parse(input, options) {
   function peg$parseGroupingSets() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 290;
+    const key = peg$currPos * 508 + 332;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -57569,11 +67090,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -57594,11 +67115,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -57616,7 +67137,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f493(s1, s2);
+      s0 = peg$f601(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -57630,7 +67151,7 @@ function peg$parse(input, options) {
   function peg$parseGroupingSet() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 291;
+    const key = peg$currPos * 508 + 333;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -57641,11 +67162,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
@@ -57653,15 +67174,15 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s5 = peg$c22;
+          s5 = peg$c26;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f494(s3);
+          s0 = peg$f602(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -57677,24 +67198,24 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 40) {
-        s1 = peg$c21;
+        s1 = peg$c25;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s3 = peg$c22;
+          s3 = peg$c26;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f495();
+          s0 = peg$f603();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -57708,7 +67229,7 @@ function peg$parse(input, options) {
         s1 = peg$parseTernaryExpr();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f496(s1);
+          s1 = peg$f604(s1);
         }
         s0 = s1;
       }
@@ -57722,7 +67243,7 @@ function peg$parse(input, options) {
   function peg$parseGroupByModifier() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 292;
+    const key = peg$currPos * 508 + 334;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -57739,7 +67260,7 @@ function peg$parse(input, options) {
       s4 = peg$parseKW_TOTALS();
       if (s4 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f497();
+        s0 = peg$f605();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -57755,11 +67276,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c251) {
+        if (s4.toLowerCase() === peg$c281) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e269); }
+          if (peg$silentFails === 0) { peg$fail(peg$e301); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -57780,7 +67301,7 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f498();
+            s0 = peg$f606();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -57800,11 +67321,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 4);
-          if (s4.toLowerCase() === peg$c252) {
+          if (s4.toLowerCase() === peg$c282) {
             peg$currPos += (4);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e270); }
+            if (peg$silentFails === 0) { peg$fail(peg$e302); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -57825,7 +67346,7 @@ function peg$parse(input, options) {
             }
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f499();
+              s0 = peg$f607();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -57849,7 +67370,7 @@ function peg$parse(input, options) {
   function peg$parseWithModifierClause() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 293;
+    const key = peg$currPos * 508 + 335;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -57865,7 +67386,7 @@ function peg$parse(input, options) {
       s3 = peg$parseKW_TOTALS();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f500();
+        s0 = peg$f608();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -57880,11 +67401,11 @@ function peg$parse(input, options) {
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         s3 = input.substr(peg$currPos, 6);
-        if (s3.toLowerCase() === peg$c251) {
+        if (s3.toLowerCase() === peg$c281) {
           peg$currPos += (6);
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e269); }
+          if (peg$silentFails === 0) { peg$fail(peg$e301); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$currPos;
@@ -57905,7 +67426,7 @@ function peg$parse(input, options) {
           }
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f501();
+            s0 = peg$f609();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -57924,11 +67445,11 @@ function peg$parse(input, options) {
         if (s1 !== peg$FAILED) {
           s2 = peg$parse_();
           s3 = input.substr(peg$currPos, 4);
-          if (s3.toLowerCase() === peg$c252) {
+          if (s3.toLowerCase() === peg$c282) {
             peg$currPos += (4);
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e270); }
+            if (peg$silentFails === 0) { peg$fail(peg$e302); }
           }
           if (s3 !== peg$FAILED) {
             s4 = peg$currPos;
@@ -57949,7 +67470,7 @@ function peg$parse(input, options) {
             }
             if (s4 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f502();
+              s0 = peg$f610();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -57973,7 +67494,7 @@ function peg$parse(input, options) {
   function peg$parseHavingClause() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 294;
+    const key = peg$currPos * 508 + 336;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -57989,7 +67510,7 @@ function peg$parse(input, options) {
       s3 = peg$parseExpression();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f503(s2, s3);
+        s0 = peg$f611(s2, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -58007,7 +67528,7 @@ function peg$parse(input, options) {
   function peg$parseQualifyClause() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 295;
+    const key = peg$currPos * 508 + 337;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -58018,11 +67539,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c253) {
+    if (s1.toLowerCase() === peg$c283) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e271); }
+      if (peg$silentFails === 0) { peg$fail(peg$e303); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -58046,7 +67567,7 @@ function peg$parse(input, options) {
         s4 = peg$parseExpression();
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f504(s3, s4);
+          s0 = peg$f612(s3, s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -58068,7 +67589,7 @@ function peg$parse(input, options) {
   function peg$parseOrderByClause() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 296;
+    const key = peg$currPos * 508 + 338;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -58087,7 +67608,7 @@ function peg$parse(input, options) {
         s5 = peg$parseOrderByItemList();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f505(s5);
+          s0 = peg$f613(s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -58109,7 +67630,7 @@ function peg$parse(input, options) {
   function peg$parseLimitByClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 297;
+    const key = peg$currPos * 508 + 339;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -58131,7 +67652,7 @@ function peg$parse(input, options) {
           s7 = peg$parseKW_ALL();
           if (s7 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f506(s3);
+            s0 = peg$f614(s3);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -58157,11 +67678,11 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s5 = peg$c15;
+            s5 = peg$c24;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
@@ -58174,7 +67695,7 @@ function peg$parse(input, options) {
                 s11 = peg$parseKW_ALL();
                 if (s11 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f507(s3, s7);
+                  s0 = peg$f615(s3, s7);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -58219,7 +67740,7 @@ function peg$parse(input, options) {
                   s11 = peg$parseKW_ALL();
                   if (s11 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f508(s3, s7);
+                    s0 = peg$f616(s3, s7);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -58253,11 +67774,11 @@ function peg$parse(input, options) {
             if (s3 !== peg$FAILED) {
               s4 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s5 = peg$c15;
+                s5 = peg$c24;
                 peg$currPos++;
               } else {
                 s5 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s5 !== peg$FAILED) {
                 s6 = peg$parse_();
@@ -58270,7 +67791,7 @@ function peg$parse(input, options) {
                     s11 = peg$parseExpressionList();
                     if (s11 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f509(s3, s7, s11);
+                      s0 = peg$f617(s3, s7, s11);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -58315,7 +67836,7 @@ function peg$parse(input, options) {
                       s11 = peg$parseExpressionList();
                       if (s11 !== peg$FAILED) {
                         peg$savedPos = s0;
-                        s0 = peg$f510(s3, s7, s11);
+                        s0 = peg$f618(s3, s7, s11);
                       } else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
@@ -58354,7 +67875,7 @@ function peg$parse(input, options) {
                     s7 = peg$parseExpressionList();
                     if (s7 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f511(s3, s7);
+                      s0 = peg$f619(s3, s7);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -58385,7 +67906,7 @@ function peg$parse(input, options) {
   function peg$parseLimitClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 298;
+    const key = peg$currPos * 508 + 340;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -58402,11 +67923,11 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -58417,11 +67938,11 @@ function peg$parse(input, options) {
             if (s9 !== peg$FAILED) {
               s10 = peg$parse_();
               s11 = input.substr(peg$currPos, 4);
-              if (s11.toLowerCase() === peg$c239) {
+              if (s11.toLowerCase() === peg$c270) {
                 peg$currPos += (4);
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e253); }
+                if (peg$silentFails === 0) { peg$fail(peg$e286); }
               }
               if (s11 !== peg$FAILED) {
                 s12 = peg$currPos;
@@ -58442,7 +67963,7 @@ function peg$parse(input, options) {
                 }
                 if (s12 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f512(s3, s7);
+                  s0 = peg$f620(s3, s7);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -58480,18 +68001,18 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s5 = peg$c15;
+            s5 = peg$c24;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = peg$parseTernaryExpr();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f513(s3, s7);
+              s0 = peg$f621(s3, s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -58520,11 +68041,11 @@ function peg$parse(input, options) {
             if (s5 !== peg$FAILED) {
               s6 = peg$parse_();
               s7 = input.substr(peg$currPos, 4);
-              if (s7.toLowerCase() === peg$c239) {
+              if (s7.toLowerCase() === peg$c270) {
                 peg$currPos += (4);
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e253); }
+                if (peg$silentFails === 0) { peg$fail(peg$e286); }
               }
               if (s7 !== peg$FAILED) {
                 s8 = peg$currPos;
@@ -58545,7 +68066,7 @@ function peg$parse(input, options) {
                 }
                 if (s8 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f514(s3);
+                  s0 = peg$f622(s3);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -58574,7 +68095,7 @@ function peg$parse(input, options) {
             s3 = peg$parseTernaryExpr();
             if (s3 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f515(s3);
+              s0 = peg$f623(s3);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -58595,7 +68116,7 @@ function peg$parse(input, options) {
   function peg$parseOffsetClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 299;
+    const key = peg$currPos * 508 + 341;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -58613,19 +68134,19 @@ function peg$parse(input, options) {
         s4 = peg$currPos;
         s5 = peg$parse_();
         s6 = input.substr(peg$currPos, 4);
-        if (s6.toLowerCase() === peg$c209) {
+        if (s6.toLowerCase() === peg$c242) {
           peg$currPos += (4);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e219); }
+          if (peg$silentFails === 0) { peg$fail(peg$e254); }
         }
         if (s6 === peg$FAILED) {
           s6 = input.substr(peg$currPos, 3);
-          if (s6.toLowerCase() === peg$c135) {
+          if (s6.toLowerCase() === peg$c133) {
             peg$currPos += (3);
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e141); }
+            if (peg$silentFails === 0) { peg$fail(peg$e142); }
           }
         }
         if (s6 !== peg$FAILED) {
@@ -58660,7 +68181,7 @@ function peg$parse(input, options) {
           s4 = null;
         }
         peg$savedPos = s0;
-        s0 = peg$f516(s3);
+        s0 = peg$f624(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -58678,7 +68199,7 @@ function peg$parse(input, options) {
   function peg$parseFetchClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;
 
-    const key = peg$currPos * 466 + 300;
+    const key = peg$currPos * 508 + 342;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -58689,11 +68210,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c75) {
+    if (s1.toLowerCase() === peg$c79) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e80); }
+      if (peg$silentFails === 0) { peg$fail(peg$e84); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -58715,19 +68236,19 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 5);
-        if (s4.toLowerCase() === peg$c29) {
+        if (s4.toLowerCase() === peg$c33) {
           peg$currPos += (5);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e33); }
+          if (peg$silentFails === 0) { peg$fail(peg$e37); }
         }
         if (s4 === peg$FAILED) {
           s4 = input.substr(peg$currPos, 4);
-          if (s4.toLowerCase() === peg$c254) {
+          if (s4.toLowerCase() === peg$c284) {
             peg$currPos += (4);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e272); }
+            if (peg$silentFails === 0) { peg$fail(peg$e304); }
           }
         }
         if (s4 !== peg$FAILED) {
@@ -58753,19 +68274,19 @@ function peg$parse(input, options) {
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
               s9 = input.substr(peg$currPos, 4);
-              if (s9.toLowerCase() === peg$c209) {
+              if (s9.toLowerCase() === peg$c242) {
                 peg$currPos += (4);
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e219); }
+                if (peg$silentFails === 0) { peg$fail(peg$e254); }
               }
               if (s9 === peg$FAILED) {
                 s9 = input.substr(peg$currPos, 3);
-                if (s9.toLowerCase() === peg$c135) {
+                if (s9.toLowerCase() === peg$c133) {
                   peg$currPos += (3);
                 } else {
                   s9 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e141); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e142); }
                 }
               }
               if (s9 !== peg$FAILED) {
@@ -58788,11 +68309,11 @@ function peg$parse(input, options) {
                 if (s10 !== peg$FAILED) {
                   s11 = peg$parse_();
                   s12 = input.substr(peg$currPos, 4);
-                  if (s12.toLowerCase() === peg$c203) {
+                  if (s12.toLowerCase() === peg$c236) {
                     peg$currPos += (4);
                   } else {
                     s12 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e213); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e248); }
                   }
                   if (s12 === peg$FAILED) {
                     s12 = peg$currPos;
@@ -58800,11 +68321,11 @@ function peg$parse(input, options) {
                     if (s13 !== peg$FAILED) {
                       s14 = peg$parse_();
                       s15 = input.substr(peg$currPos, 4);
-                      if (s15.toLowerCase() === peg$c239) {
+                      if (s15.toLowerCase() === peg$c270) {
                         peg$currPos += (4);
                       } else {
                         s15 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e253); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e286); }
                       }
                       if (s15 !== peg$FAILED) {
                         s13 = [s13, s14, s15];
@@ -58837,7 +68358,7 @@ function peg$parse(input, options) {
                     }
                     if (s13 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f517(s7, s12);
+                      s0 = peg$f625(s7, s12);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -58883,7 +68404,7 @@ function peg$parse(input, options) {
   function peg$parseSettingsClause() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 301;
+    const key = peg$currPos * 508 + 343;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -58899,7 +68420,7 @@ function peg$parse(input, options) {
       s3 = peg$parseSettingsList();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f518(s3);
+        s0 = peg$f626(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -58917,7 +68438,7 @@ function peg$parse(input, options) {
   function peg$parseWindowClause() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 302;
+    const key = peg$currPos * 508 + 344;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -58933,7 +68454,7 @@ function peg$parse(input, options) {
       s3 = peg$parseWindowItemList();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f519(s3);
+        s0 = peg$f627(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -58951,7 +68472,7 @@ function peg$parse(input, options) {
   function peg$parseWindowItemList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 303;
+    const key = peg$currPos * 508 + 345;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -58967,11 +68488,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -58992,11 +68513,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -59014,7 +68535,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f520(s1, s2);
+      s0 = peg$f628(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -59028,7 +68549,7 @@ function peg$parse(input, options) {
   function peg$parseWindowItem() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 304;
+    const key = peg$currPos * 508 + 346;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -59045,11 +68566,11 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s5 = peg$c21;
+          s5 = peg$c25;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -59059,15 +68580,15 @@ function peg$parse(input, options) {
             s9 = peg$parseWindowSpec();
             s10 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s11 = peg$c22;
+              s11 = peg$c26;
               peg$currPos++;
             } else {
               s11 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s11 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f521(s1, s7, s9);
+              s0 = peg$f629(s1, s7, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -59097,26 +68618,26 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 40) {
-            s5 = peg$c21;
+            s5 = peg$c25;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = peg$parseWindowSpec();
             s8 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s9 = peg$c22;
+              s9 = peg$c26;
               peg$currPos++;
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s9 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f522(s1, s7);
+              s0 = peg$f630(s1, s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -59143,7 +68664,7 @@ function peg$parse(input, options) {
   function peg$parseSettingsList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 305;
+    const key = peg$currPos * 508 + 347;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -59159,11 +68680,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -59184,11 +68705,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -59206,7 +68727,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f523(s1, s2);
+      s0 = peg$f631(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -59220,7 +68741,7 @@ function peg$parse(input, options) {
   function peg$parseSettingName() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 306;
+    const key = peg$currPos * 508 + 348;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -59231,33 +68752,33 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.charAt(peg$currPos);
-    if (peg$r8.test(s1)) {
+    if (peg$r5.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e184); }
+      if (peg$silentFails === 0) { peg$fail(peg$e129); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
       s3 = input.charAt(peg$currPos);
-      if (peg$r17.test(s3)) {
+      if (peg$r19.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e273); }
+        if (peg$silentFails === 0) { peg$fail(peg$e305); }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
         s3 = input.charAt(peg$currPos);
-        if (peg$r17.test(s3)) {
+        if (peg$r19.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e273); }
+          if (peg$silentFails === 0) { peg$fail(peg$e305); }
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f524(s1, s2);
+      s0 = peg$f632(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -59265,11 +68786,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 34) {
-        s1 = peg$c255;
+        s1 = peg$c285;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e274); }
+        if (peg$silentFails === 0) { peg$fail(peg$e306); }
       }
       if (s1 !== peg$FAILED) {
         s2 = [];
@@ -59279,15 +68800,15 @@ function peg$parse(input, options) {
           s3 = peg$parseDoubleQuotedChar();
         }
         if (input.charCodeAt(peg$currPos) === 34) {
-          s3 = peg$c255;
+          s3 = peg$c285;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e274); }
+          if (peg$silentFails === 0) { peg$fail(peg$e306); }
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f525(s2);
+          s0 = peg$f633(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -59299,11 +68820,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 96) {
-          s1 = peg$c219;
+          s1 = peg$c124;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e231); }
+          if (peg$silentFails === 0) { peg$fail(peg$e133); }
         }
         if (s1 !== peg$FAILED) {
           s2 = [];
@@ -59313,15 +68834,15 @@ function peg$parse(input, options) {
             s3 = peg$parseBacktickChar();
           }
           if (input.charCodeAt(peg$currPos) === 96) {
-            s3 = peg$c219;
+            s3 = peg$c124;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e231); }
+            if (peg$silentFails === 0) { peg$fail(peg$e133); }
           }
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f526(s2);
+            s0 = peg$f634(s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -59341,7 +68862,7 @@ function peg$parse(input, options) {
   function peg$parseSettingItem() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 307;
+    const key = peg$currPos * 508 + 349;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -59355,11 +68876,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 61) {
-        s3 = peg$c62;
+        s3 = peg$c66;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e67); }
+        if (peg$silentFails === 0) { peg$fail(peg$e71); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -59368,11 +68889,11 @@ function peg$parse(input, options) {
           s6 = peg$currPos;
           s7 = peg$parse_();
           s8 = input.substr(peg$currPos, 3);
-          if (s8.toLowerCase() === peg$c186) {
+          if (s8.toLowerCase() === peg$c122) {
             peg$currPos += (3);
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e196); }
+            if (peg$silentFails === 0) { peg$fail(peg$e128); }
           }
           if (s8 !== peg$FAILED) {
             s9 = peg$currPos;
@@ -59413,7 +68934,7 @@ function peg$parse(input, options) {
             s6 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f527(s1, s5, s6);
+          s0 = peg$f635(s1, s5, s6);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -59431,7 +68952,7 @@ function peg$parse(input, options) {
       s1 = peg$parseSettingName();
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f528(s1);
+        s1 = peg$f636(s1);
       }
       s0 = s1;
     }
@@ -59444,7 +68965,7 @@ function peg$parse(input, options) {
   function peg$parseOrderByItemList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 308;
+    const key = peg$currPos * 508 + 350;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -59460,11 +68981,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -59485,11 +69006,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -59507,7 +69028,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f529(s1, s2);
+      s0 = peg$f637(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -59521,7 +69042,7 @@ function peg$parse(input, options) {
   function peg$parseOrderByItem() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 
-    const key = peg$currPos * 466 + 309;
+    const key = peg$currPos * 508 + 351;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -59572,11 +69093,11 @@ function peg$parse(input, options) {
       s4 = peg$currPos;
       s5 = peg$parse_();
       s6 = input.substr(peg$currPos, 5);
-      if (s6.toLowerCase() === peg$c256) {
+      if (s6.toLowerCase() === peg$c286) {
         peg$currPos += (5);
       } else {
         s6 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e275); }
+        if (peg$silentFails === 0) { peg$fail(peg$e307); }
       }
       if (s6 !== peg$FAILED) {
         s7 = peg$currPos;
@@ -59598,19 +69119,19 @@ function peg$parse(input, options) {
         if (s7 !== peg$FAILED) {
           s8 = peg$parse_();
           s9 = input.substr(peg$currPos, 5);
-          if (s9.toLowerCase() === peg$c29) {
+          if (s9.toLowerCase() === peg$c33) {
             peg$currPos += (5);
           } else {
             s9 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e33); }
+            if (peg$silentFails === 0) { peg$fail(peg$e37); }
           }
           if (s9 === peg$FAILED) {
             s9 = input.substr(peg$currPos, 4);
-            if (s9.toLowerCase() === peg$c257) {
+            if (s9.toLowerCase() === peg$c287) {
               peg$currPos += (4);
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e276); }
+              if (peg$silentFails === 0) { peg$fail(peg$e308); }
             }
           }
           if (s9 !== peg$FAILED) {
@@ -59655,11 +69176,11 @@ function peg$parse(input, options) {
       s5 = peg$currPos;
       s6 = peg$parse_();
       s7 = input.substr(peg$currPos, 7);
-      if (s7.toLowerCase() === peg$c47) {
+      if (s7.toLowerCase() === peg$c51) {
         peg$currPos += (7);
       } else {
         s7 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e52); }
+        if (peg$silentFails === 0) { peg$fail(peg$e56); }
       }
       if (s7 !== peg$FAILED) {
         s8 = peg$currPos;
@@ -59702,11 +69223,11 @@ function peg$parse(input, options) {
       s6 = peg$currPos;
       s7 = peg$parse_();
       s8 = input.substr(peg$currPos, 4);
-      if (s8.toLowerCase() === peg$c53) {
+      if (s8.toLowerCase() === peg$c57) {
         peg$currPos += (4);
       } else {
         s8 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e58); }
+        if (peg$silentFails === 0) { peg$fail(peg$e62); }
       }
       if (s8 !== peg$FAILED) {
         s9 = peg$currPos;
@@ -59728,11 +69249,11 @@ function peg$parse(input, options) {
         if (s9 !== peg$FAILED) {
           s10 = peg$parse_();
           s11 = input.substr(peg$currPos, 4);
-          if (s11.toLowerCase() === peg$c258) {
+          if (s11.toLowerCase() === peg$c288) {
             peg$currPos += (4);
           } else {
             s11 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e277); }
+            if (peg$silentFails === 0) { peg$fail(peg$e309); }
           }
           if (s11 !== peg$FAILED) {
             s12 = peg$currPos;
@@ -59775,7 +69296,7 @@ function peg$parse(input, options) {
         s6 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f530(s1, s2, s3, s4, s5, s6);
+      s0 = peg$f638(s1, s2, s3, s4, s5, s6);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -59789,7 +69310,7 @@ function peg$parse(input, options) {
   function peg$parseWithFillArgs() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14;
 
-    const key = peg$currPos * 466 + 310;
+    const key = peg$currPos * 508 + 352;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -59802,11 +69323,11 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     s2 = peg$parse_();
     s3 = input.substr(peg$currPos, 4);
-    if (s3.toLowerCase() === peg$c69) {
+    if (s3.toLowerCase() === peg$c73) {
       peg$currPos += (4);
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e74); }
+      if (peg$silentFails === 0) { peg$fail(peg$e78); }
     }
     if (s3 !== peg$FAILED) {
       s4 = peg$currPos;
@@ -59896,11 +69417,11 @@ function peg$parse(input, options) {
     s3 = peg$currPos;
     s4 = peg$parse_();
     s5 = input.substr(peg$currPos, 4);
-    if (s5.toLowerCase() === peg$c259) {
+    if (s5.toLowerCase() === peg$c289) {
       peg$currPos += (4);
     } else {
       s5 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e278); }
+      if (peg$silentFails === 0) { peg$fail(peg$e310); }
     }
     if (s5 !== peg$FAILED) {
       s6 = peg$currPos;
@@ -59943,11 +69464,11 @@ function peg$parse(input, options) {
     s4 = peg$currPos;
     s5 = peg$parse_();
     s6 = input.substr(peg$currPos, 9);
-    if (s6.toLowerCase() === peg$c260) {
+    if (s6.toLowerCase() === peg$c290) {
       peg$currPos += (9);
     } else {
       s6 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e279); }
+      if (peg$silentFails === 0) { peg$fail(peg$e311); }
     }
     if (s6 !== peg$FAILED) {
       s7 = peg$currPos;
@@ -59990,11 +69511,11 @@ function peg$parse(input, options) {
     s5 = peg$currPos;
     s6 = peg$parse_();
     s7 = input.substr(peg$currPos, 11);
-    if (s7.toLowerCase() === peg$c261) {
+    if (s7.toLowerCase() === peg$c291) {
       peg$currPos += (11);
     } else {
       s7 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e280); }
+      if (peg$silentFails === 0) { peg$fail(peg$e312); }
     }
     if (s7 !== peg$FAILED) {
       s8 = peg$currPos;
@@ -60016,11 +69537,11 @@ function peg$parse(input, options) {
       if (s8 !== peg$FAILED) {
         s9 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s10 = peg$c21;
+          s10 = peg$c25;
           peg$currPos++;
         } else {
           s10 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s10 !== peg$FAILED) {
           s11 = peg$parse_();
@@ -60028,11 +69549,11 @@ function peg$parse(input, options) {
           if (s12 !== peg$FAILED) {
             s13 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s14 = peg$c22;
+              s14 = peg$c26;
               peg$currPos++;
             } else {
               s14 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s14 !== peg$FAILED) {
               s6 = [s6, s7, s8, s9, s10, s11, s12, s13, s14];
@@ -60061,7 +69582,7 @@ function peg$parse(input, options) {
       s5 = null;
     }
     peg$savedPos = s0;
-    s0 = peg$f531(s1, s2, s3, s4, s5);
+    s0 = peg$f639(s1, s2, s3, s4, s5);
 
     peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
 
@@ -60071,7 +69592,7 @@ function peg$parse(input, options) {
   function peg$parseInterpolateList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 311;
+    const key = peg$currPos * 508 + 353;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60087,11 +69608,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -60112,11 +69633,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -60134,7 +69655,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f532(s1, s2);
+      s0 = peg$f640(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -60143,7 +69664,7 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s1 = peg$parse_();
       peg$savedPos = s0;
-      s1 = peg$f533();
+      s1 = peg$f641();
       s0 = s1;
     }
 
@@ -60155,7 +69676,7 @@ function peg$parse(input, options) {
   function peg$parseInterpolateItem() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 312;
+    const key = peg$currPos * 508 + 354;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60174,7 +69695,7 @@ function peg$parse(input, options) {
         s5 = peg$parseExpression();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f534(s1, s5);
+          s0 = peg$f642(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -60192,7 +69713,7 @@ function peg$parse(input, options) {
       s1 = peg$parseIdentifier();
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f535(s1);
+        s1 = peg$f643(s1);
       }
       s0 = s1;
     }
@@ -60205,7 +69726,7 @@ function peg$parse(input, options) {
   function peg$parseExpressionList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 313;
+    const key = peg$currPos * 508 + 355;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60221,11 +69742,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -60246,11 +69767,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -60268,7 +69789,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f536(s1, s2);
+      s0 = peg$f644(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -60282,7 +69803,7 @@ function peg$parse(input, options) {
   function peg$parseExpression() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 314;
+    const key = peg$currPos * 508 + 356;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60301,7 +69822,7 @@ function peg$parse(input, options) {
         s5 = peg$parseAliasName();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f537(s1, s2, s5);
+          s0 = peg$f645(s1, s2, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -60326,7 +69847,7 @@ function peg$parse(input, options) {
   function peg$parseExpressionWithImplicitAlias() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 315;
+    const key = peg$currPos * 508 + 357;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60345,7 +69866,7 @@ function peg$parse(input, options) {
         s5 = peg$parseAliasName();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f538(s1, s2, s5);
+          s0 = peg$f646(s1, s2, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -60374,16 +69895,16 @@ function peg$parse(input, options) {
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e50); }
+            if (peg$silentFails === 0) { peg$fail(peg$e54); }
           }
           if (s7 === peg$FAILED) {
             s7 = peg$currPos;
             s8 = input.substr(peg$currPos, 4);
-            if (s8.toLowerCase() === peg$c69) {
+            if (s8.toLowerCase() === peg$c73) {
               peg$currPos += (4);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e74); }
+              if (peg$silentFails === 0) { peg$fail(peg$e78); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -60416,11 +69937,11 @@ function peg$parse(input, options) {
             if (s7 === peg$FAILED) {
               s7 = peg$currPos;
               s8 = input.substr(peg$currPos, 3);
-              if (s8.toLowerCase() === peg$c186) {
+              if (s8.toLowerCase() === peg$c122) {
                 peg$currPos += (3);
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e196); }
+                if (peg$silentFails === 0) { peg$fail(peg$e128); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = peg$currPos;
@@ -60468,7 +69989,7 @@ function peg$parse(input, options) {
           }
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f539(s1, s2, s3);
+            s0 = peg$f647(s1, s2, s3);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -60494,7 +70015,7 @@ function peg$parse(input, options) {
   function peg$parseTernaryExpr() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 316;
+    const key = peg$currPos * 508 + 358;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60508,11 +70029,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 63) {
-        s3 = peg$c262;
+        s3 = peg$c292;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e281); }
+        if (peg$silentFails === 0) { peg$fail(peg$e313); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -60520,18 +70041,18 @@ function peg$parse(input, options) {
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 58) {
-            s7 = peg$c263;
+            s7 = peg$c293;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e282); }
+            if (peg$silentFails === 0) { peg$fail(peg$e314); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$parse_();
             s9 = peg$parseTernaryExpr();
             if (s9 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f540(s1, s2, s4, s5, s6, s8, s9);
+              s0 = peg$f648(s1, s2, s4, s5, s6, s8, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -60564,7 +70085,7 @@ function peg$parse(input, options) {
   function peg$parseOrExpr() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 317;
+    const key = peg$currPos * 508 + 359;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60620,7 +70141,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f541(s1, s2);
+        s0 = peg$f649(s1, s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -60641,7 +70162,7 @@ function peg$parse(input, options) {
   function peg$parseAndExpr() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 318;
+    const key = peg$currPos * 508 + 360;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60697,7 +70218,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f542(s1, s2);
+        s0 = peg$f650(s1, s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -60718,7 +70239,7 @@ function peg$parse(input, options) {
   function peg$parseNotExpr() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 319;
+    const key = peg$currPos * 508 + 361;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60735,11 +70256,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s5 = peg$c21;
+        s5 = peg$c25;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s5 !== peg$FAILED) {
         s4 = [s4, s5];
@@ -60760,7 +70281,7 @@ function peg$parse(input, options) {
         s4 = peg$parseNotExpr();
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f543(s3, s4);
+          s0 = peg$f651(s3, s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -60785,7 +70306,7 @@ function peg$parse(input, options) {
   function peg$parseCompareExpr() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 320;
+    const key = peg$currPos * 508 + 362;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60836,7 +70357,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f544(s1, s2);
+      s0 = peg$f652(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -60850,7 +70371,7 @@ function peg$parse(input, options) {
   function peg$parseCompareBase() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 321;
+    const key = peg$currPos * 508 + 363;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60869,7 +70390,7 @@ function peg$parse(input, options) {
         s3 = peg$parseCompareBaseSuffix();
       }
       peg$savedPos = s0;
-      s0 = peg$f545(s1, s2);
+      s0 = peg$f653(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -60883,7 +70404,7 @@ function peg$parse(input, options) {
   function peg$parseCompareBaseSuffix() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;
 
-    const key = peg$currPos * 466 + 322;
+    const key = peg$currPos * 508 + 364;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -60926,7 +70447,7 @@ function peg$parse(input, options) {
       s6 = peg$parseInTarget();
       if (s6 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f546(s2, s3, s6);
+        s0 = peg$f654(s2, s3, s6);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -60957,7 +70478,7 @@ function peg$parse(input, options) {
         s5 = peg$parseAddExpr();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f547(s2, s5);
+          s0 = peg$f655(s2, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -60988,7 +70509,7 @@ function peg$parse(input, options) {
           s5 = peg$parseAddExpr();
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f548(s2, s5);
+            s0 = peg$f656(s2, s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -61001,11 +70522,11 @@ function peg$parse(input, options) {
           s0 = peg$currPos;
           s1 = peg$parse_();
           s2 = input.substr(peg$currPos, 6);
-          if (s2.toLowerCase() === peg$c179) {
+          if (s2.toLowerCase() === peg$c217) {
             peg$currPos += (6);
           } else {
             s2 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e189); }
+            if (peg$silentFails === 0) { peg$fail(peg$e229); }
           }
           if (s2 !== peg$FAILED) {
             s3 = peg$currPos;
@@ -61029,7 +70550,7 @@ function peg$parse(input, options) {
               s5 = peg$parseAddExpr();
               if (s5 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f549(s5);
+                s0 = peg$f657(s5);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -61060,7 +70581,7 @@ function peg$parse(input, options) {
                     s10 = peg$parseAddExpr();
                     if (s10 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f550(s6, s10);
+                      s0 = peg$f658(s6, s10);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -61096,7 +70617,7 @@ function peg$parse(input, options) {
                     s8 = peg$parseAddExpr();
                     if (s8 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f551(s4, s8);
+                      s0 = peg$f659(s4, s8);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -61116,19 +70637,19 @@ function peg$parse(input, options) {
               if (s0 === peg$FAILED) {
                 s0 = peg$currPos;
                 s1 = peg$parse_();
-                if (input.substr(peg$currPos, 2) === peg$c264) {
-                  s2 = peg$c264;
+                if (input.substr(peg$currPos, 2) === peg$c294) {
+                  s2 = peg$c294;
                   peg$currPos += 2;
                 } else {
                   s2 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e283); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e315); }
                 }
                 if (s2 !== peg$FAILED) {
                   s3 = peg$parse_();
                   s4 = peg$parseClickHouseType();
                   if (s4 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f552(s4);
+                    s0 = peg$f660(s4);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -61141,11 +70662,11 @@ function peg$parse(input, options) {
                   s0 = peg$currPos;
                   s1 = peg$parse_();
                   s2 = input.substr(peg$currPos, 2);
-                  if (s2.toLowerCase() === peg$c265) {
+                  if (s2.toLowerCase() === peg$c295) {
                     peg$currPos += (2);
                   } else {
                     s2 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e284); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e316); }
                   }
                   if (s2 !== peg$FAILED) {
                     s3 = peg$currPos;
@@ -61167,11 +70688,11 @@ function peg$parse(input, options) {
                     if (s3 !== peg$FAILED) {
                       s4 = peg$parse_();
                       s5 = input.substr(peg$currPos, 3);
-                      if (s5.toLowerCase() === peg$c26) {
+                      if (s5.toLowerCase() === peg$c30) {
                         peg$currPos += (3);
                       } else {
                         s5 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e34); }
                       }
                       if (s5 !== peg$FAILED) {
                         s6 = peg$currPos;
@@ -61193,11 +70714,11 @@ function peg$parse(input, options) {
                         if (s6 !== peg$FAILED) {
                           s7 = peg$parse_();
                           s8 = input.substr(peg$currPos, 4);
-                          if (s8.toLowerCase() === peg$c44) {
+                          if (s8.toLowerCase() === peg$c48) {
                             peg$currPos += (4);
                           } else {
                             s8 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e52); }
                           }
                           if (s8 !== peg$FAILED) {
                             s9 = peg$currPos;
@@ -61256,7 +70777,7 @@ function peg$parse(input, options) {
                                 }
                               }
                               peg$savedPos = s0;
-                              s0 = peg$f553(s10);
+                              s0 = peg$f661(s10);
                             } else {
                               peg$currPos = s0;
                               s0 = peg$FAILED;
@@ -61285,11 +70806,11 @@ function peg$parse(input, options) {
                     s0 = peg$currPos;
                     s1 = peg$parse_();
                     s2 = input.substr(peg$currPos, 2);
-                    if (s2.toLowerCase() === peg$c265) {
+                    if (s2.toLowerCase() === peg$c295) {
                       peg$currPos += (2);
                     } else {
                       s2 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e284); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e316); }
                     }
                     if (s2 !== peg$FAILED) {
                       s3 = peg$currPos;
@@ -61311,11 +70832,11 @@ function peg$parse(input, options) {
                       if (s3 !== peg$FAILED) {
                         s4 = peg$parse_();
                         s5 = input.substr(peg$currPos, 4);
-                        if (s5.toLowerCase() === peg$c44) {
+                        if (s5.toLowerCase() === peg$c48) {
                           peg$currPos += (4);
                         } else {
                           s5 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e48); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e52); }
                         }
                         if (s5 !== peg$FAILED) {
                           s6 = peg$currPos;
@@ -61374,7 +70895,7 @@ function peg$parse(input, options) {
                               }
                             }
                             peg$savedPos = s0;
-                            s0 = peg$f554(s7);
+                            s0 = peg$f662(s7);
                           } else {
                             peg$currPos = s0;
                             s0 = peg$FAILED;
@@ -61408,7 +70929,7 @@ function peg$parse(input, options) {
   function peg$parseExtendedCompareOp() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
 
-    const key = peg$currPos * 466 + 323;
+    const key = peg$currPos * 508 + 365;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -61419,11 +70940,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c265) {
+    if (s1.toLowerCase() === peg$c295) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e284); }
+      if (peg$silentFails === 0) { peg$fail(peg$e316); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -61445,11 +70966,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 3);
-        if (s4.toLowerCase() === peg$c26) {
+        if (s4.toLowerCase() === peg$c30) {
           peg$currPos += (3);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e30); }
+          if (peg$silentFails === 0) { peg$fail(peg$e34); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -61471,11 +70992,11 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = input.substr(peg$currPos, 8);
-            if (s7.toLowerCase() === peg$c237) {
+            if (s7.toLowerCase() === peg$c268) {
               peg$currPos += (8);
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e251); }
+              if (peg$silentFails === 0) { peg$fail(peg$e284); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$currPos;
@@ -61497,11 +71018,11 @@ function peg$parse(input, options) {
               if (s8 !== peg$FAILED) {
                 s9 = peg$parse_();
                 s10 = input.substr(peg$currPos, 4);
-                if (s10.toLowerCase() === peg$c69) {
+                if (s10.toLowerCase() === peg$c73) {
                   peg$currPos += (4);
                 } else {
                   s10 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e74); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e78); }
                 }
                 if (s10 !== peg$FAILED) {
                   s11 = peg$currPos;
@@ -61522,7 +71043,7 @@ function peg$parse(input, options) {
                   }
                   if (s11 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f555();
+                    s0 = peg$f663();
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -61558,11 +71079,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 2);
-      if (s1.toLowerCase() === peg$c265) {
+      if (s1.toLowerCase() === peg$c295) {
         peg$currPos += (2);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e284); }
+        if (peg$silentFails === 0) { peg$fail(peg$e316); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -61584,11 +71105,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 8);
-          if (s4.toLowerCase() === peg$c237) {
+          if (s4.toLowerCase() === peg$c268) {
             peg$currPos += (8);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e251); }
+            if (peg$silentFails === 0) { peg$fail(peg$e284); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -61610,11 +71131,11 @@ function peg$parse(input, options) {
             if (s5 !== peg$FAILED) {
               s6 = peg$parse_();
               s7 = input.substr(peg$currPos, 4);
-              if (s7.toLowerCase() === peg$c69) {
+              if (s7.toLowerCase() === peg$c73) {
                 peg$currPos += (4);
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e74); }
+                if (peg$silentFails === 0) { peg$fail(peg$e78); }
               }
               if (s7 !== peg$FAILED) {
                 s8 = peg$currPos;
@@ -61635,7 +71156,7 @@ function peg$parse(input, options) {
                 }
                 if (s8 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f556();
+                  s0 = peg$f664();
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -61665,7 +71186,7 @@ function peg$parse(input, options) {
         s1 = peg$parseCompareOp();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f557(s1);
+          s1 = peg$f665(s1);
         }
         s0 = s1;
       }
@@ -61679,7 +71200,7 @@ function peg$parse(input, options) {
   function peg$parseInTarget() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 324;
+    const key = peg$currPos * 508 + 366;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -61692,17 +71213,17 @@ function peg$parse(input, options) {
     s1 = peg$parseArrayLiteral();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f558(s1);
+      s1 = peg$f666(s1);
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 40) {
-        s1 = peg$c21;
+        s1 = peg$c25;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
@@ -61710,15 +71231,15 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 41) {
-            s5 = peg$c22;
+            s5 = peg$c26;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e26); }
+            if (peg$silentFails === 0) { peg$fail(peg$e30); }
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f559(s2, s3, s4);
+            s0 = peg$f667(s2, s3, s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -61736,7 +71257,7 @@ function peg$parse(input, options) {
         s1 = peg$parsePrimaryExpr();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f560(s1);
+          s1 = peg$f668(s1);
         }
         s0 = s1;
       }
@@ -61750,7 +71271,7 @@ function peg$parse(input, options) {
   function peg$parseCompareOp() {
     let s0;
 
-    const key = peg$currPos * 466 + 325;
+    const key = peg$currPos * 508 + 367;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -61759,60 +71280,60 @@ function peg$parse(input, options) {
       return cached.result;
     }
 
-    if (input.substr(peg$currPos, 3) === peg$c266) {
-      s0 = peg$c266;
+    if (input.substr(peg$currPos, 3) === peg$c296) {
+      s0 = peg$c296;
       peg$currPos += 3;
     } else {
       s0 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e285); }
+      if (peg$silentFails === 0) { peg$fail(peg$e317); }
     }
     if (s0 === peg$FAILED) {
-      if (input.substr(peg$currPos, 2) === peg$c267) {
-        s0 = peg$c267;
+      if (input.substr(peg$currPos, 2) === peg$c297) {
+        s0 = peg$c297;
         peg$currPos += 2;
       } else {
         s0 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e286); }
+        if (peg$silentFails === 0) { peg$fail(peg$e318); }
       }
       if (s0 === peg$FAILED) {
-        if (input.substr(peg$currPos, 2) === peg$c268) {
-          s0 = peg$c268;
+        if (input.substr(peg$currPos, 2) === peg$c298) {
+          s0 = peg$c298;
           peg$currPos += 2;
         } else {
           s0 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e287); }
+          if (peg$silentFails === 0) { peg$fail(peg$e319); }
         }
         if (s0 === peg$FAILED) {
-          if (input.substr(peg$currPos, 2) === peg$c269) {
-            s0 = peg$c269;
+          if (input.substr(peg$currPos, 2) === peg$c299) {
+            s0 = peg$c299;
             peg$currPos += 2;
           } else {
             s0 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e288); }
+            if (peg$silentFails === 0) { peg$fail(peg$e320); }
           }
           if (s0 === peg$FAILED) {
-            if (input.substr(peg$currPos, 2) === peg$c270) {
-              s0 = peg$c270;
+            if (input.substr(peg$currPos, 2) === peg$c300) {
+              s0 = peg$c300;
               peg$currPos += 2;
             } else {
               s0 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e289); }
+              if (peg$silentFails === 0) { peg$fail(peg$e321); }
             }
             if (s0 === peg$FAILED) {
-              if (input.substr(peg$currPos, 2) === peg$c271) {
-                s0 = peg$c271;
+              if (input.substr(peg$currPos, 2) === peg$c301) {
+                s0 = peg$c301;
                 peg$currPos += 2;
               } else {
                 s0 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e290); }
+                if (peg$silentFails === 0) { peg$fail(peg$e322); }
               }
               if (s0 === peg$FAILED) {
                 s0 = input.charAt(peg$currPos);
-                if (peg$r18.test(s0)) {
+                if (peg$r20.test(s0)) {
                   peg$currPos++;
                 } else {
                   s0 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e291); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e323); }
                 }
               }
             }
@@ -61829,7 +71350,7 @@ function peg$parse(input, options) {
   function peg$parseCompareRightExpr() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 326;
+    const key = peg$currPos * 508 + 368;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -61845,7 +71366,7 @@ function peg$parse(input, options) {
       s3 = peg$parseCompareRightExpr();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f561(s3);
+        s0 = peg$f669(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -61865,7 +71386,7 @@ function peg$parse(input, options) {
           s3 = peg$parseCompareBaseSuffix();
         }
         peg$savedPos = s0;
-        s0 = peg$f562(s1, s2);
+        s0 = peg$f670(s1, s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -61880,7 +71401,7 @@ function peg$parse(input, options) {
   function peg$parseInValues() {
     let s0, s1;
 
-    const key = peg$currPos * 466 + 327;
+    const key = peg$currPos * 508 + 369;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -61893,7 +71414,7 @@ function peg$parse(input, options) {
     s1 = peg$parseUnionQuery();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f563(s1);
+      s1 = peg$f671(s1);
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
@@ -61908,7 +71429,7 @@ function peg$parse(input, options) {
   function peg$parseAddExpr() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 328;
+    const key = peg$currPos * 508 + 370;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -61959,7 +71480,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f564(s1, s2);
+      s0 = peg$f672(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -61973,7 +71494,7 @@ function peg$parse(input, options) {
   function peg$parseNotPrefixExpr() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 329;
+    const key = peg$currPos * 508 + 371;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -61989,7 +71510,7 @@ function peg$parse(input, options) {
       s3 = peg$parseNotPrefixExpr();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f565(s3);
+        s0 = peg$f673(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -62010,7 +71531,7 @@ function peg$parse(input, options) {
   function peg$parseAddOp() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 330;
+    const key = peg$currPos * 508 + 372;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -62020,30 +71541,30 @@ function peg$parse(input, options) {
     }
 
     if (input.charCodeAt(peg$currPos) === 43) {
-      s0 = peg$c272;
+      s0 = peg$c302;
       peg$currPos++;
     } else {
       s0 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e292); }
+      if (peg$silentFails === 0) { peg$fail(peg$e324); }
     }
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 45) {
-        s1 = peg$c273;
+        s1 = peg$c303;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e293); }
+        if (peg$silentFails === 0) { peg$fail(peg$e325); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
         peg$silentFails++;
         if (input.charCodeAt(peg$currPos) === 62) {
-          s3 = peg$c274;
+          s3 = peg$c304;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e294); }
+          if (peg$silentFails === 0) { peg$fail(peg$e326); }
         }
         peg$silentFails--;
         if (s3 === peg$FAILED) {
@@ -62054,7 +71575,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f566();
+          s0 = peg$f674();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -62066,15 +71587,15 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 8722) {
-          s1 = peg$c275;
+          s1 = peg$c305;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e295); }
+          if (peg$silentFails === 0) { peg$fail(peg$e327); }
         }
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f567();
+          s1 = peg$f675();
         }
         s0 = s1;
       }
@@ -62088,7 +71609,7 @@ function peg$parse(input, options) {
   function peg$parseConcatExpr() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 331;
+    const key = peg$currPos * 508 + 373;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -62103,12 +71624,12 @@ function peg$parse(input, options) {
       s2 = [];
       s3 = peg$currPos;
       s4 = peg$parse_();
-      if (input.substr(peg$currPos, 2) === peg$c276) {
-        s5 = peg$c276;
+      if (input.substr(peg$currPos, 2) === peg$c306) {
+        s5 = peg$c306;
         peg$currPos += 2;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e296); }
+        if (peg$silentFails === 0) { peg$fail(peg$e328); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -62128,12 +71649,12 @@ function peg$parse(input, options) {
         s2.push(s3);
         s3 = peg$currPos;
         s4 = peg$parse_();
-        if (input.substr(peg$currPos, 2) === peg$c276) {
-          s5 = peg$c276;
+        if (input.substr(peg$currPos, 2) === peg$c306) {
+          s5 = peg$c306;
           peg$currPos += 2;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e296); }
+          if (peg$silentFails === 0) { peg$fail(peg$e328); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -62151,7 +71672,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f568(s1, s2);
+      s0 = peg$f676(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -62165,7 +71686,7 @@ function peg$parse(input, options) {
   function peg$parseMulExpr() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 332;
+    const key = peg$currPos * 508 + 374;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -62216,7 +71737,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f569(s1, s2);
+      s0 = peg$f677(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -62230,7 +71751,7 @@ function peg$parse(input, options) {
   function peg$parseMulOp() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 333;
+    const key = peg$currPos * 508 + 375;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -62240,20 +71761,20 @@ function peg$parse(input, options) {
     }
 
     s0 = input.charAt(peg$currPos);
-    if (peg$r19.test(s0)) {
+    if (peg$r21.test(s0)) {
       peg$currPos++;
     } else {
       s0 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e297); }
+      if (peg$silentFails === 0) { peg$fail(peg$e329); }
     }
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 3);
-      if (s1.toLowerCase() === peg$c277) {
+      if (s1.toLowerCase() === peg$c307) {
         peg$currPos += (3);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e298); }
+        if (peg$silentFails === 0) { peg$fail(peg$e330); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -62274,7 +71795,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f570();
+          s0 = peg$f678();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -62286,11 +71807,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 3);
-        if (s1.toLowerCase() === peg$c278) {
+        if (s1.toLowerCase() === peg$c308) {
           peg$currPos += (3);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e299); }
+          if (peg$silentFails === 0) { peg$fail(peg$e331); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -62311,7 +71832,7 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f571();
+            s0 = peg$f679();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -62331,7 +71852,7 @@ function peg$parse(input, options) {
   function peg$parseUnaryExpr() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 334;
+    const key = peg$currPos * 508 + 376;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -62342,18 +71863,18 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 43) {
-      s1 = peg$c272;
+      s1 = peg$c302;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e292); }
+      if (peg$silentFails === 0) { peg$fail(peg$e324); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       s3 = peg$parseUnaryExpr();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f572(s3);
+        s0 = peg$f680(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -62365,18 +71886,18 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.charAt(peg$currPos);
-      if (peg$r20.test(s1)) {
+      if (peg$r22.test(s1)) {
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e300); }
+        if (peg$silentFails === 0) { peg$fail(peg$e332); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         s3 = peg$parseUnaryExpr();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f573(s3);
+          s0 = peg$f681(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -62398,7 +71919,7 @@ function peg$parse(input, options) {
   function peg$parsePrimaryExpr() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 335;
+    const key = peg$currPos * 508 + 377;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -62425,7 +71946,7 @@ function peg$parse(input, options) {
         s4 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f574(s1, s2, s4);
+      s0 = peg$f682(s1, s2, s4);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -62439,7 +71960,7 @@ function peg$parse(input, options) {
   function peg$parseNullsHandlingClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 336;
+    const key = peg$currPos * 508 + 378;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -62451,19 +71972,19 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 7);
-    if (s2.toLowerCase() === peg$c279) {
+    if (s2.toLowerCase() === peg$c309) {
       peg$currPos += (7);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e301); }
+      if (peg$silentFails === 0) { peg$fail(peg$e333); }
     }
     if (s2 === peg$FAILED) {
       s2 = input.substr(peg$currPos, 6);
-      if (s2.toLowerCase() === peg$c280) {
+      if (s2.toLowerCase() === peg$c310) {
         peg$currPos += (6);
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e302); }
+        if (peg$silentFails === 0) { peg$fail(peg$e334); }
       }
     }
     if (s2 !== peg$FAILED) {
@@ -62486,11 +72007,11 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 5);
-        if (s5.toLowerCase() === peg$c256) {
+        if (s5.toLowerCase() === peg$c286) {
           peg$currPos += (5);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e275); }
+          if (peg$silentFails === 0) { peg$fail(peg$e307); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -62537,7 +72058,7 @@ function peg$parse(input, options) {
   function peg$parseOverClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 337;
+    const key = peg$currPos * 508 + 379;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -62549,11 +72070,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 4);
-    if (s2.toLowerCase() === peg$c281) {
+    if (s2.toLowerCase() === peg$c311) {
       peg$currPos += (4);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e303); }
+      if (peg$silentFails === 0) { peg$fail(peg$e335); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -62575,11 +72096,11 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s5 = peg$c21;
+          s5 = peg$c25;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -62589,15 +72110,15 @@ function peg$parse(input, options) {
             s9 = peg$parseWindowSpec();
             s10 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s11 = peg$c22;
+              s11 = peg$c26;
               peg$currPos++;
             } else {
               s11 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s11 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f575(s9);
+              s0 = peg$f683(s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -62622,11 +72143,11 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s1 = peg$parse_();
       s2 = input.substr(peg$currPos, 4);
-      if (s2.toLowerCase() === peg$c281) {
+      if (s2.toLowerCase() === peg$c311) {
         peg$currPos += (4);
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e303); }
+        if (peg$silentFails === 0) { peg$fail(peg$e335); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
@@ -62648,26 +72169,26 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 40) {
-            s5 = peg$c21;
+            s5 = peg$c25;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = peg$parseWindowSpec();
             s8 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s9 = peg$c22;
+              s9 = peg$c26;
               peg$currPos++;
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s9 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f576(s7);
+              s0 = peg$f684(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -62688,11 +72209,11 @@ function peg$parse(input, options) {
         s0 = peg$currPos;
         s1 = peg$parse_();
         s2 = input.substr(peg$currPos, 4);
-        if (s2.toLowerCase() === peg$c281) {
+        if (s2.toLowerCase() === peg$c311) {
           peg$currPos += (4);
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e303); }
+          if (peg$silentFails === 0) { peg$fail(peg$e335); }
         }
         if (s2 !== peg$FAILED) {
           s3 = peg$currPos;
@@ -62716,7 +72237,7 @@ function peg$parse(input, options) {
             s5 = peg$parseIdentifier();
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f577();
+              s0 = peg$f685();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -62740,7 +72261,7 @@ function peg$parse(input, options) {
   function peg$parseWindowSpec() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 338;
+    const key = peg$currPos * 508 + 380;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -62752,11 +72273,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$currPos;
     s2 = input.substr(peg$currPos, 9);
-    if (s2.toLowerCase() === peg$c66) {
+    if (s2.toLowerCase() === peg$c70) {
       peg$currPos += (9);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e71); }
+      if (peg$silentFails === 0) { peg$fail(peg$e75); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -62778,11 +72299,11 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = input.substr(peg$currPos, 2);
-        if (s5.toLowerCase() === peg$c80) {
+        if (s5.toLowerCase() === peg$c84) {
           peg$currPos += (2);
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e85); }
+          if (peg$silentFails === 0) { peg$fail(peg$e89); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$currPos;
@@ -62806,7 +72327,7 @@ function peg$parse(input, options) {
             s8 = peg$parseExpressionList();
             if (s8 !== peg$FAILED) {
               peg$savedPos = s1;
-              s1 = peg$f578(s8);
+              s1 = peg$f686(s8);
             } else {
               peg$currPos = s1;
               s1 = peg$FAILED;
@@ -62833,11 +72354,11 @@ function peg$parse(input, options) {
     s2 = peg$parse_();
     s3 = peg$currPos;
     s4 = input.substr(peg$currPos, 5);
-    if (s4.toLowerCase() === peg$c79) {
+    if (s4.toLowerCase() === peg$c83) {
       peg$currPos += (5);
     } else {
       s4 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e84); }
+      if (peg$silentFails === 0) { peg$fail(peg$e88); }
     }
     if (s4 !== peg$FAILED) {
       s5 = peg$currPos;
@@ -62859,11 +72380,11 @@ function peg$parse(input, options) {
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
         s7 = input.substr(peg$currPos, 2);
-        if (s7.toLowerCase() === peg$c80) {
+        if (s7.toLowerCase() === peg$c84) {
           peg$currPos += (2);
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e85); }
+          if (peg$silentFails === 0) { peg$fail(peg$e89); }
         }
         if (s7 !== peg$FAILED) {
           s8 = peg$currPos;
@@ -62887,7 +72408,7 @@ function peg$parse(input, options) {
             s10 = peg$parseOrderByItemList();
             if (s10 !== peg$FAILED) {
               peg$savedPos = s3;
-              s3 = peg$f579(s1, s10);
+              s3 = peg$f687(s1, s10);
             } else {
               peg$currPos = s3;
               s3 = peg$FAILED;
@@ -62917,7 +72438,7 @@ function peg$parse(input, options) {
       s5 = null;
     }
     peg$savedPos = s0;
-    s0 = peg$f580(s1, s3, s5);
+    s0 = peg$f688(s1, s3, s5);
 
     peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
 
@@ -62927,7 +72448,7 @@ function peg$parse(input, options) {
   function peg$parseWindowFrameClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 339;
+    const key = peg$currPos * 508 + 381;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -62941,11 +72462,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       s3 = input.substr(peg$currPos, 7);
-      if (s3.toLowerCase() === peg$c282) {
+      if (s3.toLowerCase() === peg$c312) {
         peg$currPos += (7);
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e304); }
+        if (peg$silentFails === 0) { peg$fail(peg$e336); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$currPos;
@@ -62970,11 +72491,11 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             s8 = input.substr(peg$currPos, 3);
-            if (s8.toLowerCase() === peg$c145) {
+            if (s8.toLowerCase() === peg$c189) {
               peg$currPos += (3);
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e151); }
+              if (peg$silentFails === 0) { peg$fail(peg$e198); }
             }
             if (s8 !== peg$FAILED) {
               s9 = peg$currPos;
@@ -62998,7 +72519,7 @@ function peg$parse(input, options) {
                 s11 = peg$parseWindowFrameBound();
                 if (s11 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f581(s1, s6, s11);
+                  s0 = peg$f689(s1, s6, s11);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -63035,7 +72556,7 @@ function peg$parse(input, options) {
         s3 = peg$parseWindowFrameBound();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f582(s1, s3);
+          s0 = peg$f690(s1, s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -63054,7 +72575,7 @@ function peg$parse(input, options) {
   function peg$parseWindowFrameType() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 340;
+    const key = peg$currPos * 508 + 382;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -63065,27 +72586,27 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c209) {
+    if (s1.toLowerCase() === peg$c242) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e219); }
+      if (peg$silentFails === 0) { peg$fail(peg$e254); }
     }
     if (s1 === peg$FAILED) {
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c161) {
+      if (s1.toLowerCase() === peg$c205) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e167); }
+        if (peg$silentFails === 0) { peg$fail(peg$e214); }
       }
       if (s1 === peg$FAILED) {
         s1 = input.substr(peg$currPos, 6);
-        if (s1.toLowerCase() === peg$c283) {
+        if (s1.toLowerCase() === peg$c313) {
           peg$currPos += (6);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e305); }
+          if (peg$silentFails === 0) { peg$fail(peg$e337); }
         }
       }
     }
@@ -63108,7 +72629,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f583();
+        s0 = peg$f691();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -63126,7 +72647,7 @@ function peg$parse(input, options) {
   function peg$parseWindowFrameBound() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 341;
+    const key = peg$currPos * 508 + 383;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -63137,11 +72658,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 9);
-    if (s1.toLowerCase() === peg$c284) {
+    if (s1.toLowerCase() === peg$c314) {
       peg$currPos += (9);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e306); }
+      if (peg$silentFails === 0) { peg$fail(peg$e338); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -63163,11 +72684,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 9);
-        if (s4.toLowerCase() === peg$c285) {
+        if (s4.toLowerCase() === peg$c315) {
           peg$currPos += (9);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e307); }
+          if (peg$silentFails === 0) { peg$fail(peg$e339); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -63188,7 +72709,7 @@ function peg$parse(input, options) {
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f584();
+            s0 = peg$f692();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -63208,11 +72729,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 9);
-      if (s1.toLowerCase() === peg$c284) {
+      if (s1.toLowerCase() === peg$c314) {
         peg$currPos += (9);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e306); }
+        if (peg$silentFails === 0) { peg$fail(peg$e338); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -63234,11 +72755,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 9);
-          if (s4.toLowerCase() === peg$c286) {
+          if (s4.toLowerCase() === peg$c316) {
             peg$currPos += (9);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e308); }
+            if (peg$silentFails === 0) { peg$fail(peg$e340); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -63259,7 +72780,7 @@ function peg$parse(input, options) {
             }
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f585();
+              s0 = peg$f693();
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -63279,11 +72800,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 7);
-        if (s1.toLowerCase() === peg$c230) {
+        if (s1.toLowerCase() === peg$c162) {
           peg$currPos += (7);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e244); }
+          if (peg$silentFails === 0) { peg$fail(peg$e171); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -63305,11 +72826,11 @@ function peg$parse(input, options) {
           if (s2 !== peg$FAILED) {
             s3 = peg$parse_();
             s4 = input.substr(peg$currPos, 3);
-            if (s4.toLowerCase() === peg$c135) {
+            if (s4.toLowerCase() === peg$c133) {
               peg$currPos += (3);
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e141); }
+              if (peg$silentFails === 0) { peg$fail(peg$e142); }
             }
             if (s4 !== peg$FAILED) {
               s5 = peg$currPos;
@@ -63330,7 +72851,7 @@ function peg$parse(input, options) {
               }
               if (s5 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f586();
+                s0 = peg$f694();
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -63353,11 +72874,11 @@ function peg$parse(input, options) {
           if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
             s3 = input.substr(peg$currPos, 9);
-            if (s3.toLowerCase() === peg$c285) {
+            if (s3.toLowerCase() === peg$c315) {
               peg$currPos += (9);
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e307); }
+              if (peg$silentFails === 0) { peg$fail(peg$e339); }
             }
             if (s3 !== peg$FAILED) {
               s4 = peg$currPos;
@@ -63378,7 +72899,7 @@ function peg$parse(input, options) {
               }
               if (s4 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f587(s1);
+                s0 = peg$f695(s1);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -63397,11 +72918,11 @@ function peg$parse(input, options) {
             if (s1 !== peg$FAILED) {
               s2 = peg$parse_();
               s3 = input.substr(peg$currPos, 9);
-              if (s3.toLowerCase() === peg$c286) {
+              if (s3.toLowerCase() === peg$c316) {
                 peg$currPos += (9);
               } else {
                 s3 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e308); }
+                if (peg$silentFails === 0) { peg$fail(peg$e340); }
               }
               if (s3 !== peg$FAILED) {
                 s4 = peg$currPos;
@@ -63422,7 +72943,7 @@ function peg$parse(input, options) {
                 }
                 if (s4 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f588(s1);
+                  s0 = peg$f696(s1);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -63448,7 +72969,7 @@ function peg$parse(input, options) {
   function peg$parsePrimaryExprSuffix() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 342;
+    const key = peg$currPos * 508 + 384;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -63459,19 +72980,19 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = peg$parse_();
-    if (input.substr(peg$currPos, 2) === peg$c264) {
-      s2 = peg$c264;
+    if (input.substr(peg$currPos, 2) === peg$c294) {
+      s2 = peg$c294;
       peg$currPos += 2;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e283); }
+      if (peg$silentFails === 0) { peg$fail(peg$e315); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$parse_();
       s4 = peg$parseClickHouseType();
       if (s4 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f589(s4);
+        s0 = peg$f697(s4);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -63483,19 +73004,19 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 46) {
-        s1 = peg$c35;
+        s1 = peg$c39;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s1 !== peg$FAILED) {
         if (input.charCodeAt(peg$currPos) === 58) {
-          s2 = peg$c263;
+          s2 = peg$c293;
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e282); }
+          if (peg$silentFails === 0) { peg$fail(peg$e314); }
         }
         if (s2 !== peg$FAILED) {
           s3 = peg$parseJsonSubcolumnType();
@@ -63503,17 +73024,17 @@ function peg$parse(input, options) {
             s4 = [];
             s5 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 46) {
-              s6 = peg$c35;
+              s6 = peg$c39;
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e39); }
+              if (peg$silentFails === 0) { peg$fail(peg$e43); }
             }
             if (s6 !== peg$FAILED) {
               s7 = peg$parseIdentifier();
               if (s7 !== peg$FAILED) {
                 peg$savedPos = s5;
-                s5 = peg$f590(s3, s7);
+                s5 = peg$f698(s3, s7);
               } else {
                 peg$currPos = s5;
                 s5 = peg$FAILED;
@@ -63526,17 +73047,17 @@ function peg$parse(input, options) {
               s4.push(s5);
               s5 = peg$currPos;
               if (input.charCodeAt(peg$currPos) === 46) {
-                s6 = peg$c35;
+                s6 = peg$c39;
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e39); }
+                if (peg$silentFails === 0) { peg$fail(peg$e43); }
               }
               if (s6 !== peg$FAILED) {
                 s7 = peg$parseIdentifier();
                 if (s7 !== peg$FAILED) {
                   peg$savedPos = s5;
-                  s5 = peg$f590(s3, s7);
+                  s5 = peg$f698(s3, s7);
                 } else {
                   peg$currPos = s5;
                   s5 = peg$FAILED;
@@ -63547,7 +73068,7 @@ function peg$parse(input, options) {
               }
             }
             peg$savedPos = s0;
-            s0 = peg$f591(s3, s4);
+            s0 = peg$f699(s3, s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -63564,11 +73085,11 @@ function peg$parse(input, options) {
         s0 = peg$currPos;
         s1 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 91) {
-          s2 = peg$c287;
+          s2 = peg$c317;
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e309); }
+          if (peg$silentFails === 0) { peg$fail(peg$e341); }
         }
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
@@ -63576,15 +73097,15 @@ function peg$parse(input, options) {
           if (s4 !== peg$FAILED) {
             s5 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 93) {
-              s6 = peg$c288;
+              s6 = peg$c318;
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e310); }
+              if (peg$silentFails === 0) { peg$fail(peg$e342); }
             }
             if (s6 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f592(s4);
+              s0 = peg$f700(s4);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -63601,11 +73122,11 @@ function peg$parse(input, options) {
           s0 = peg$currPos;
           s1 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 46) {
-            s2 = peg$c35;
+            s2 = peg$c39;
             peg$currPos++;
           } else {
             s2 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e39); }
+            if (peg$silentFails === 0) { peg$fail(peg$e43); }
           }
           if (s2 !== peg$FAILED) {
             s3 = peg$parse_();
@@ -63639,7 +73160,7 @@ function peg$parse(input, options) {
             }
             if (s4 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f593(s4);
+              s0 = peg$f701(s4);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -63652,20 +73173,20 @@ function peg$parse(input, options) {
             s0 = peg$currPos;
             s1 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 46) {
-              s2 = peg$c35;
+              s2 = peg$c39;
               peg$currPos++;
             } else {
               s2 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e39); }
+              if (peg$silentFails === 0) { peg$fail(peg$e43); }
             }
             if (s2 !== peg$FAILED) {
               s3 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 45) {
-                s4 = peg$c273;
+                s4 = peg$c303;
                 peg$currPos++;
               } else {
                 s4 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e293); }
+                if (peg$silentFails === 0) { peg$fail(peg$e325); }
               }
               if (s4 !== peg$FAILED) {
                 s5 = peg$currPos;
@@ -63698,7 +73219,7 @@ function peg$parse(input, options) {
                 }
                 if (s5 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f594(s5);
+                  s0 = peg$f702(s5);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -63715,22 +73236,22 @@ function peg$parse(input, options) {
               s0 = peg$currPos;
               s1 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 46) {
-                s2 = peg$c35;
+                s2 = peg$c39;
                 peg$currPos++;
               } else {
                 s2 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e39); }
+                if (peg$silentFails === 0) { peg$fail(peg$e43); }
               }
               if (s2 !== peg$FAILED) {
                 s3 = peg$parse_();
                 s4 = peg$currPos;
                 peg$silentFails++;
                 s5 = input.charAt(peg$currPos);
-                if (peg$r21.test(s5)) {
+                if (peg$r23.test(s5)) {
                   peg$currPos++;
                 } else {
                   s5 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e311); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e343); }
                 }
                 peg$silentFails--;
                 if (s5 === peg$FAILED) {
@@ -63743,7 +73264,7 @@ function peg$parse(input, options) {
                   s5 = peg$parseAliasName();
                   if (s5 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f595(s5);
+                    s0 = peg$f703(s5);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -63760,20 +73281,20 @@ function peg$parse(input, options) {
                 s0 = peg$currPos;
                 s1 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 46) {
-                  s2 = peg$c35;
+                  s2 = peg$c39;
                   peg$currPos++;
                 } else {
                   s2 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e39); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e43); }
                 }
                 if (s2 !== peg$FAILED) {
                   s3 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 42) {
-                    s4 = peg$c185;
+                    s4 = peg$c123;
                     peg$currPos++;
                   } else {
                     s4 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e195); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e130); }
                   }
                   if (s4 !== peg$FAILED) {
                     s5 = [];
@@ -63801,7 +73322,7 @@ function peg$parse(input, options) {
                       }
                     }
                     peg$savedPos = s0;
-                    s0 = peg$f596(s5);
+                    s0 = peg$f704(s5);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -63825,7 +73346,7 @@ function peg$parse(input, options) {
   function peg$parseJsonSubcolumnType() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 343;
+    const key = peg$currPos * 508 + 385;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -63836,11 +73357,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 96) {
-      s1 = peg$c219;
+      s1 = peg$c124;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e231); }
+      if (peg$silentFails === 0) { peg$fail(peg$e133); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
@@ -63850,15 +73371,15 @@ function peg$parse(input, options) {
         s3 = peg$parseBacktickChar();
       }
       if (input.charCodeAt(peg$currPos) === 96) {
-        s3 = peg$c219;
+        s3 = peg$c124;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e231); }
+        if (peg$silentFails === 0) { peg$fail(peg$e133); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f597(s2);
+        s0 = peg$f705(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -63879,7 +73400,7 @@ function peg$parse(input, options) {
   function peg$parseMultiWordType() {
     let s0, s1;
 
-    const key = peg$currPos * 466 + 344;
+    const key = peg$currPos * 508 + 386;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -63892,7 +73413,7 @@ function peg$parse(input, options) {
     s1 = peg$parseMultiWordTypeInner();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f598();
+      s1 = peg$f706();
     }
     s0 = s1;
 
@@ -63904,7 +73425,7 @@ function peg$parse(input, options) {
   function peg$parseMultiWordTypeInner() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 345;
+    const key = peg$currPos * 508 + 387;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -63915,20 +73436,20 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c289) {
+    if (s1.toLowerCase() === peg$c319) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e312); }
+      if (peg$silentFails === 0) { peg$fail(peg$e344); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       s3 = input.substr(peg$currPos, 9);
-      if (s3.toLowerCase() === peg$c290) {
+      if (s3.toLowerCase() === peg$c320) {
         peg$currPos += (9);
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e313); }
+        if (peg$silentFails === 0) { peg$fail(peg$e345); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$currPos;
@@ -63965,47 +73486,47 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 8);
-      if (s1.toLowerCase() === peg$c291) {
+      if (s1.toLowerCase() === peg$c321) {
         peg$currPos += (8);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e314); }
+        if (peg$silentFails === 0) { peg$fail(peg$e346); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         s3 = input.substr(peg$currPos, 9);
-        if (s3.toLowerCase() === peg$c292) {
+        if (s3.toLowerCase() === peg$c322) {
           peg$currPos += (9);
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e315); }
+          if (peg$silentFails === 0) { peg$fail(peg$e347); }
         }
         if (s3 === peg$FAILED) {
           s3 = input.substr(peg$currPos, 4);
-          if (s3.toLowerCase() === peg$c293) {
+          if (s3.toLowerCase() === peg$c323) {
             peg$currPos += (4);
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e316); }
+            if (peg$silentFails === 0) { peg$fail(peg$e348); }
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           s5 = input.substr(peg$currPos, 5);
-          if (s5.toLowerCase() === peg$c294) {
+          if (s5.toLowerCase() === peg$c324) {
             peg$currPos += (5);
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e317); }
+            if (peg$silentFails === 0) { peg$fail(peg$e349); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = input.substr(peg$currPos, 6);
-            if (s7.toLowerCase() === peg$c295) {
+            if (s7.toLowerCase() === peg$c325) {
               peg$currPos += (6);
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e318); }
+              if (peg$silentFails === 0) { peg$fail(peg$e350); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$currPos;
@@ -64050,38 +73571,38 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 8);
-        if (s1.toLowerCase() === peg$c291) {
+        if (s1.toLowerCase() === peg$c321) {
           peg$currPos += (8);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e314); }
+          if (peg$silentFails === 0) { peg$fail(peg$e346); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$parse_();
           s3 = input.substr(peg$currPos, 9);
-          if (s3.toLowerCase() === peg$c292) {
+          if (s3.toLowerCase() === peg$c322) {
             peg$currPos += (9);
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e315); }
+            if (peg$silentFails === 0) { peg$fail(peg$e347); }
           }
           if (s3 === peg$FAILED) {
             s3 = input.substr(peg$currPos, 4);
-            if (s3.toLowerCase() === peg$c293) {
+            if (s3.toLowerCase() === peg$c323) {
               peg$currPos += (4);
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e316); }
+              if (peg$silentFails === 0) { peg$fail(peg$e348); }
             }
           }
           if (s3 !== peg$FAILED) {
             s4 = peg$parse_();
             s5 = input.substr(peg$currPos, 7);
-            if (s5.toLowerCase() === peg$c296) {
+            if (s5.toLowerCase() === peg$c326) {
               peg$currPos += (7);
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e319); }
+              if (peg$silentFails === 0) { peg$fail(peg$e351); }
             }
             if (s5 !== peg$FAILED) {
               s6 = peg$currPos;
@@ -64122,28 +73643,28 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 8);
-          if (s1.toLowerCase() === peg$c291) {
+          if (s1.toLowerCase() === peg$c321) {
             peg$currPos += (8);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e314); }
+            if (peg$silentFails === 0) { peg$fail(peg$e346); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
             s3 = input.substr(peg$currPos, 9);
-            if (s3.toLowerCase() === peg$c292) {
+            if (s3.toLowerCase() === peg$c322) {
               peg$currPos += (9);
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e315); }
+              if (peg$silentFails === 0) { peg$fail(peg$e347); }
             }
             if (s3 === peg$FAILED) {
               s3 = input.substr(peg$currPos, 4);
-              if (s3.toLowerCase() === peg$c293) {
+              if (s3.toLowerCase() === peg$c323) {
                 peg$currPos += (4);
               } else {
                 s3 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e316); }
+                if (peg$silentFails === 0) { peg$fail(peg$e348); }
               }
             }
             if (s3 !== peg$FAILED) {
@@ -64181,29 +73702,29 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 5);
-            if (s1.toLowerCase() === peg$c297) {
+            if (s1.toLowerCase() === peg$c327) {
               peg$currPos += (5);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e320); }
+              if (peg$silentFails === 0) { peg$fail(peg$e352); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$parse_();
               s3 = input.substr(peg$currPos, 5);
-              if (s3.toLowerCase() === peg$c294) {
+              if (s3.toLowerCase() === peg$c324) {
                 peg$currPos += (5);
               } else {
                 s3 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e317); }
+                if (peg$silentFails === 0) { peg$fail(peg$e349); }
               }
               if (s3 !== peg$FAILED) {
                 s4 = peg$parse_();
                 s5 = input.substr(peg$currPos, 6);
-                if (s5.toLowerCase() === peg$c295) {
+                if (s5.toLowerCase() === peg$c325) {
                   peg$currPos += (6);
                 } else {
                   s5 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e318); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e350); }
                 }
                 if (s5 !== peg$FAILED) {
                   s6 = peg$currPos;
@@ -64244,20 +73765,20 @@ function peg$parse(input, options) {
             if (s0 === peg$FAILED) {
               s0 = peg$currPos;
               s1 = input.substr(peg$currPos, 5);
-              if (s1.toLowerCase() === peg$c297) {
+              if (s1.toLowerCase() === peg$c327) {
                 peg$currPos += (5);
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e320); }
+                if (peg$silentFails === 0) { peg$fail(peg$e352); }
               }
               if (s1 !== peg$FAILED) {
                 s2 = peg$parse_();
                 s3 = input.substr(peg$currPos, 7);
-                if (s3.toLowerCase() === peg$c296) {
+                if (s3.toLowerCase() === peg$c326) {
                   peg$currPos += (7);
                 } else {
                   s3 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e319); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e351); }
                 }
                 if (s3 !== peg$FAILED) {
                   s4 = peg$currPos;
@@ -64294,47 +73815,47 @@ function peg$parse(input, options) {
               if (s0 === peg$FAILED) {
                 s0 = peg$currPos;
                 s1 = input.substr(peg$currPos, 9);
-                if (s1.toLowerCase() === peg$c292) {
+                if (s1.toLowerCase() === peg$c322) {
                   peg$currPos += (9);
                 } else {
                   s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e315); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e347); }
                 }
                 if (s1 === peg$FAILED) {
                   s1 = input.substr(peg$currPos, 4);
-                  if (s1.toLowerCase() === peg$c293) {
+                  if (s1.toLowerCase() === peg$c323) {
                     peg$currPos += (4);
                   } else {
                     s1 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e316); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e348); }
                   }
                   if (s1 === peg$FAILED) {
                     s1 = input.substr(peg$currPos, 6);
-                    if (s1.toLowerCase() === peg$c298) {
+                    if (s1.toLowerCase() === peg$c328) {
                       peg$currPos += (6);
                     } else {
                       s1 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e321); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e353); }
                     }
                   }
                 }
                 if (s1 !== peg$FAILED) {
                   s2 = peg$parse_();
                   s3 = input.substr(peg$currPos, 5);
-                  if (s3.toLowerCase() === peg$c294) {
+                  if (s3.toLowerCase() === peg$c324) {
                     peg$currPos += (5);
                   } else {
                     s3 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e317); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e349); }
                   }
                   if (s3 !== peg$FAILED) {
                     s4 = peg$parse_();
                     s5 = input.substr(peg$currPos, 6);
-                    if (s5.toLowerCase() === peg$c295) {
+                    if (s5.toLowerCase() === peg$c325) {
                       peg$currPos += (6);
                     } else {
                       s5 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e318); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e350); }
                     }
                     if (s5 !== peg$FAILED) {
                       s6 = peg$currPos;
@@ -64375,38 +73896,38 @@ function peg$parse(input, options) {
                 if (s0 === peg$FAILED) {
                   s0 = peg$currPos;
                   s1 = input.substr(peg$currPos, 9);
-                  if (s1.toLowerCase() === peg$c292) {
+                  if (s1.toLowerCase() === peg$c322) {
                     peg$currPos += (9);
                   } else {
                     s1 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e315); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e347); }
                   }
                   if (s1 === peg$FAILED) {
                     s1 = input.substr(peg$currPos, 4);
-                    if (s1.toLowerCase() === peg$c293) {
+                    if (s1.toLowerCase() === peg$c323) {
                       peg$currPos += (4);
                     } else {
                       s1 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e316); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e348); }
                     }
                     if (s1 === peg$FAILED) {
                       s1 = input.substr(peg$currPos, 6);
-                      if (s1.toLowerCase() === peg$c298) {
+                      if (s1.toLowerCase() === peg$c328) {
                         peg$currPos += (6);
                       } else {
                         s1 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e321); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e353); }
                       }
                     }
                   }
                   if (s1 !== peg$FAILED) {
                     s2 = peg$parse_();
                     s3 = input.substr(peg$currPos, 7);
-                    if (s3.toLowerCase() === peg$c296) {
+                    if (s3.toLowerCase() === peg$c326) {
                       peg$currPos += (7);
                     } else {
                       s3 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e319); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e351); }
                     }
                     if (s3 !== peg$FAILED) {
                       s4 = peg$currPos;
@@ -64443,28 +73964,28 @@ function peg$parse(input, options) {
                   if (s0 === peg$FAILED) {
                     s0 = peg$currPos;
                     s1 = input.substr(peg$currPos, 4);
-                    if (s1.toLowerCase() === peg$c299) {
+                    if (s1.toLowerCase() === peg$c329) {
                       peg$currPos += (4);
                     } else {
                       s1 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e322); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e354); }
                     }
                     if (s1 !== peg$FAILED) {
                       s2 = peg$parse_();
                       s3 = input.substr(peg$currPos, 6);
-                      if (s3.toLowerCase() === peg$c300) {
+                      if (s3.toLowerCase() === peg$c330) {
                         peg$currPos += (6);
                       } else {
                         s3 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e323); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e355); }
                       }
                       if (s3 === peg$FAILED) {
                         s3 = input.substr(peg$currPos, 8);
-                        if (s3.toLowerCase() === peg$c301) {
+                        if (s3.toLowerCase() === peg$c331) {
                           peg$currPos += (8);
                         } else {
                           s3 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e324); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e356); }
                         }
                       }
                       if (s3 !== peg$FAILED) {
@@ -64502,46 +74023,46 @@ function peg$parse(input, options) {
                     if (s0 === peg$FAILED) {
                       s0 = peg$currPos;
                       s1 = input.substr(peg$currPos, 7);
-                      if (s1.toLowerCase() === peg$c302) {
+                      if (s1.toLowerCase() === peg$c332) {
                         peg$currPos += (7);
                       } else {
                         s1 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e325); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e357); }
                       }
                       if (s1 === peg$FAILED) {
                         s1 = input.substr(peg$currPos, 8);
-                        if (s1.toLowerCase() === peg$c303) {
+                        if (s1.toLowerCase() === peg$c333) {
                           peg$currPos += (8);
                         } else {
                           s1 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e326); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e358); }
                         }
                         if (s1 === peg$FAILED) {
                           s1 = input.substr(peg$currPos, 6);
-                          if (s1.toLowerCase() === peg$c304) {
+                          if (s1.toLowerCase() === peg$c334) {
                             peg$currPos += (6);
                           } else {
                             s1 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e327); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e359); }
                           }
                         }
                       }
                       if (s1 !== peg$FAILED) {
                         s2 = peg$parse_();
                         s3 = input.substr(peg$currPos, 6);
-                        if (s3.toLowerCase() === peg$c300) {
+                        if (s3.toLowerCase() === peg$c330) {
                           peg$currPos += (6);
                         } else {
                           s3 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e323); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e355); }
                         }
                         if (s3 === peg$FAILED) {
                           s3 = input.substr(peg$currPos, 8);
-                          if (s3.toLowerCase() === peg$c301) {
+                          if (s3.toLowerCase() === peg$c331) {
                             peg$currPos += (8);
                           } else {
                             s3 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e324); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e356); }
                           }
                         }
                         if (s3 !== peg$FAILED) {
@@ -64579,46 +74100,46 @@ function peg$parse(input, options) {
                       if (s0 === peg$FAILED) {
                         s0 = peg$currPos;
                         s1 = input.substr(peg$currPos, 9);
-                        if (s1.toLowerCase() === peg$c305) {
+                        if (s1.toLowerCase() === peg$c335) {
                           peg$currPos += (9);
                         } else {
                           s1 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e328); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e360); }
                         }
                         if (s1 === peg$FAILED) {
                           s1 = input.substr(peg$currPos, 7);
-                          if (s1.toLowerCase() === peg$c306) {
+                          if (s1.toLowerCase() === peg$c336) {
                             peg$currPos += (7);
                           } else {
                             s1 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e329); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e361); }
                           }
                           if (s1 === peg$FAILED) {
                             s1 = input.substr(peg$currPos, 3);
-                            if (s1.toLowerCase() === peg$c307) {
+                            if (s1.toLowerCase() === peg$c337) {
                               peg$currPos += (3);
                             } else {
                               s1 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e330); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e362); }
                             }
                           }
                         }
                         if (s1 !== peg$FAILED) {
                           s2 = peg$parse_();
                           s3 = input.substr(peg$currPos, 6);
-                          if (s3.toLowerCase() === peg$c300) {
+                          if (s3.toLowerCase() === peg$c330) {
                             peg$currPos += (6);
                           } else {
                             s3 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e323); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e355); }
                           }
                           if (s3 === peg$FAILED) {
                             s3 = input.substr(peg$currPos, 8);
-                            if (s3.toLowerCase() === peg$c301) {
+                            if (s3.toLowerCase() === peg$c331) {
                               peg$currPos += (8);
                             } else {
                               s3 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e324); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e356); }
                             }
                           }
                           if (s3 !== peg$FAILED) {
@@ -64672,7 +74193,7 @@ function peg$parse(input, options) {
   function peg$parseColumnDataType() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 346;
+    const key = peg$currPos * 508 + 388;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -64687,11 +74208,11 @@ function peg$parse(input, options) {
       s2 = peg$currPos;
       s3 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s4 = peg$c21;
+        s4 = peg$c25;
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s4 !== peg$FAILED) {
         s5 = peg$parse_();
@@ -64701,11 +74222,11 @@ function peg$parse(input, options) {
         }
         s7 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s8 = peg$c22;
+          s8 = peg$c26;
           peg$currPos++;
         } else {
           s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s8 !== peg$FAILED) {
           s3 = [s3, s4, s5, s6, s7, s8];
@@ -64722,7 +74243,7 @@ function peg$parse(input, options) {
         s2 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f599(s1, s2);
+      s0 = peg$f707(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -64730,31 +74251,31 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 96) {
-        s1 = peg$c219;
+        s1 = peg$c124;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e231); }
+        if (peg$silentFails === 0) { peg$fail(peg$e133); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
         s3 = [];
         s4 = input.charAt(peg$currPos);
-        if (peg$r11.test(s4)) {
+        if (peg$r13.test(s4)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e232); }
+          if (peg$silentFails === 0) { peg$fail(peg$e266); }
         }
         if (s4 !== peg$FAILED) {
           while (s4 !== peg$FAILED) {
             s3.push(s4);
             s4 = input.charAt(peg$currPos);
-            if (peg$r11.test(s4)) {
+            if (peg$r13.test(s4)) {
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e232); }
+              if (peg$silentFails === 0) { peg$fail(peg$e266); }
             }
           }
         } else {
@@ -64767,15 +74288,15 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           if (input.charCodeAt(peg$currPos) === 96) {
-            s3 = peg$c219;
+            s3 = peg$c124;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e231); }
+            if (peg$silentFails === 0) { peg$fail(peg$e133); }
           }
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f600(s2);
+            s0 = peg$f708(s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -64791,31 +74312,31 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 34) {
-          s1 = peg$c255;
+          s1 = peg$c285;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e274); }
+          if (peg$silentFails === 0) { peg$fail(peg$e306); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
           s3 = [];
           s4 = input.charAt(peg$currPos);
-          if (peg$r22.test(s4)) {
+          if (peg$r24.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e331); }
+            if (peg$silentFails === 0) { peg$fail(peg$e363); }
           }
           if (s4 !== peg$FAILED) {
             while (s4 !== peg$FAILED) {
               s3.push(s4);
               s4 = input.charAt(peg$currPos);
-              if (peg$r22.test(s4)) {
+              if (peg$r24.test(s4)) {
                 peg$currPos++;
               } else {
                 s4 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e331); }
+                if (peg$silentFails === 0) { peg$fail(peg$e363); }
               }
             }
           } else {
@@ -64828,15 +74349,15 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 34) {
-              s3 = peg$c255;
+              s3 = peg$c285;
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e274); }
+              if (peg$silentFails === 0) { peg$fail(peg$e306); }
             }
             if (s3 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f601(s2);
+              s0 = peg$f709(s2);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -64853,28 +74374,28 @@ function peg$parse(input, options) {
           s0 = peg$currPos;
           s1 = peg$currPos;
           s2 = input.substr(peg$currPos, 5);
-          if (s2.toLowerCase() === peg$c308) {
+          if (s2.toLowerCase() === peg$c338) {
             peg$currPos += (5);
           } else {
             s2 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e332); }
+            if (peg$silentFails === 0) { peg$fail(peg$e364); }
           }
           if (s2 === peg$FAILED) {
             s2 = input.substr(peg$currPos, 6);
-            if (s2.toLowerCase() === peg$c309) {
+            if (s2.toLowerCase() === peg$c339) {
               peg$currPos += (6);
             } else {
               s2 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e333); }
+              if (peg$silentFails === 0) { peg$fail(peg$e365); }
             }
             if (s2 === peg$FAILED) {
               s2 = peg$currPos;
               s3 = input.substr(peg$currPos, 4);
-              if (s3.toLowerCase() === peg$c310) {
+              if (s3.toLowerCase() === peg$c340) {
                 peg$currPos += (4);
               } else {
                 s3 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e334); }
+                if (peg$silentFails === 0) { peg$fail(peg$e366); }
               }
               if (s3 !== peg$FAILED) {
                 s4 = peg$currPos;
@@ -64914,11 +74435,11 @@ function peg$parse(input, options) {
           if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s3 = peg$c21;
+              s3 = peg$c25;
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s3 !== peg$FAILED) {
               s4 = peg$parse_();
@@ -64926,15 +74447,15 @@ function peg$parse(input, options) {
               if (s5 !== peg$FAILED) {
                 s6 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 41) {
-                  s7 = peg$c22;
+                  s7 = peg$c26;
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
                 if (s7 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f602(s1, s5);
+                  s0 = peg$f710(s1, s5);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -64955,28 +74476,28 @@ function peg$parse(input, options) {
             s0 = peg$currPos;
             s1 = peg$currPos;
             s2 = input.substr(peg$currPos, 5);
-            if (s2.toLowerCase() === peg$c308) {
+            if (s2.toLowerCase() === peg$c338) {
               peg$currPos += (5);
             } else {
               s2 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e332); }
+              if (peg$silentFails === 0) { peg$fail(peg$e364); }
             }
             if (s2 === peg$FAILED) {
               s2 = input.substr(peg$currPos, 6);
-              if (s2.toLowerCase() === peg$c309) {
+              if (s2.toLowerCase() === peg$c339) {
                 peg$currPos += (6);
               } else {
                 s2 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e333); }
+                if (peg$silentFails === 0) { peg$fail(peg$e365); }
               }
               if (s2 === peg$FAILED) {
                 s2 = peg$currPos;
                 s3 = input.substr(peg$currPos, 4);
-                if (s3.toLowerCase() === peg$c310) {
+                if (s3.toLowerCase() === peg$c340) {
                   peg$currPos += (4);
                 } else {
                   s3 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e334); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e366); }
                 }
                 if (s3 !== peg$FAILED) {
                   s4 = peg$currPos;
@@ -65015,7 +74536,7 @@ function peg$parse(input, options) {
             }
             if (s1 !== peg$FAILED) {
               peg$savedPos = s0;
-              s1 = peg$f603(s1);
+              s1 = peg$f711(s1);
             }
             s0 = s1;
             if (s0 === peg$FAILED) {
@@ -65023,11 +74544,11 @@ function peg$parse(input, options) {
               s1 = peg$currPos;
               s2 = peg$currPos;
               s3 = input.charAt(peg$currPos);
-              if (peg$r8.test(s3)) {
+              if (peg$r5.test(s3)) {
                 peg$currPos++;
               } else {
                 s3 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e184); }
+                if (peg$silentFails === 0) { peg$fail(peg$e129); }
               }
               if (s3 !== peg$FAILED) {
                 s4 = [];
@@ -65063,11 +74584,11 @@ function peg$parse(input, options) {
                 s2 = peg$currPos;
                 s3 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 40) {
-                  s4 = peg$c21;
+                  s4 = peg$c25;
                   peg$currPos++;
                 } else {
                   s4 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e29); }
                 }
                 if (s4 !== peg$FAILED) {
                   s5 = peg$parse_();
@@ -65077,11 +74598,11 @@ function peg$parse(input, options) {
                   }
                   s7 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 41) {
-                    s8 = peg$c22;
+                    s8 = peg$c26;
                     peg$currPos++;
                   } else {
                     s8 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
                   }
                   if (s8 !== peg$FAILED) {
                     s3 = [s3, s4, s5, s6, s7, s8];
@@ -65100,19 +74621,19 @@ function peg$parse(input, options) {
                 s3 = peg$currPos;
                 s4 = peg$parse_();
                 s5 = input.substr(peg$currPos, 6);
-                if (s5.toLowerCase() === peg$c300) {
+                if (s5.toLowerCase() === peg$c330) {
                   peg$currPos += (6);
                 } else {
                   s5 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e323); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e355); }
                 }
                 if (s5 === peg$FAILED) {
                   s5 = input.substr(peg$currPos, 8);
-                  if (s5.toLowerCase() === peg$c301) {
+                  if (s5.toLowerCase() === peg$c331) {
                     peg$currPos += (8);
                   } else {
                     s5 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e324); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e356); }
                   }
                 }
                 if (s5 !== peg$FAILED) {
@@ -65147,7 +74668,7 @@ function peg$parse(input, options) {
                   s3 = null;
                 }
                 peg$savedPos = s0;
-                s0 = peg$f604(s1, s2, s3);
+                s0 = peg$f712(s1, s2, s3);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -65166,7 +74687,7 @@ function peg$parse(input, options) {
   function peg$parseEnumValueList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 347;
+    const key = peg$currPos * 508 + 389;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -65182,11 +74703,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -65207,11 +74728,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -65229,7 +74750,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f605(s1, s2);
+      s0 = peg$f713(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -65243,7 +74764,7 @@ function peg$parse(input, options) {
   function peg$parseEnumValue() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 348;
+    const key = peg$currPos * 508 + 390;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -65257,22 +74778,22 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 61) {
-        s3 = peg$c62;
+        s3 = peg$c66;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e67); }
+        if (peg$silentFails === 0) { peg$fail(peg$e71); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$currPos;
         s6 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 45) {
-          s7 = peg$c273;
+          s7 = peg$c303;
           peg$currPos++;
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e293); }
+          if (peg$silentFails === 0) { peg$fail(peg$e325); }
         }
         if (s7 === peg$FAILED) {
           s7 = null;
@@ -65314,7 +74835,7 @@ function peg$parse(input, options) {
         }
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f606(s1, s5);
+          s0 = peg$f714(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -65330,11 +74851,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c44) {
+      if (s1.toLowerCase() === peg$c48) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e48); }
+        if (peg$silentFails === 0) { peg$fail(peg$e52); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -65355,7 +74876,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f607();
+          s0 = peg$f715();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -65369,7 +74890,7 @@ function peg$parse(input, options) {
         s1 = peg$parseStringLiteral();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f608(s1);
+          s1 = peg$f716(s1);
         }
         s0 = s1;
       }
@@ -65383,7 +74904,7 @@ function peg$parse(input, options) {
   function peg$parseColumnDataTypeArgList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 349;
+    const key = peg$currPos * 508 + 391;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -65399,11 +74920,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -65424,11 +74945,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -65448,11 +74969,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s4 = [s4, s5];
@@ -65465,7 +74986,7 @@ function peg$parse(input, options) {
         s3 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f609(s1, s2, s3);
+      s0 = peg$f717(s1, s2, s3);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -65479,7 +75000,7 @@ function peg$parse(input, options) {
   function peg$parseColumnDataTypeArg() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 350;
+    const key = peg$currPos * 508 + 392;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -65490,11 +75011,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c311) {
+    if (s1.toLowerCase() === peg$c341) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e335); }
+      if (peg$silentFails === 0) { peg$fail(peg$e367); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -65516,11 +75037,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c179) {
+        if (s4.toLowerCase() === peg$c217) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e189); }
+          if (peg$silentFails === 0) { peg$fail(peg$e229); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -65544,37 +75065,37 @@ function peg$parse(input, options) {
             s7 = peg$currPos;
             s8 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 39) {
-              s9 = peg$c108;
+              s9 = peg$c99;
               peg$currPos++;
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e113); }
+              if (peg$silentFails === 0) { peg$fail(peg$e104); }
             }
             if (s9 !== peg$FAILED) {
               s10 = [];
               s11 = input.charAt(peg$currPos);
-              if (peg$r5.test(s11)) {
+              if (peg$r8.test(s11)) {
                 peg$currPos++;
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e178); }
+                if (peg$silentFails === 0) { peg$fail(peg$e219); }
               }
               while (s11 !== peg$FAILED) {
                 s10.push(s11);
                 s11 = input.charAt(peg$currPos);
-                if (peg$r5.test(s11)) {
+                if (peg$r8.test(s11)) {
                   peg$currPos++;
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e178); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e219); }
                 }
               }
               if (input.charCodeAt(peg$currPos) === 39) {
-                s11 = peg$c108;
+                s11 = peg$c99;
                 peg$currPos++;
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e113); }
+                if (peg$silentFails === 0) { peg$fail(peg$e104); }
               }
               if (s11 !== peg$FAILED) {
                 s9 = [s9, s10, s11];
@@ -65594,7 +75115,7 @@ function peg$parse(input, options) {
             }
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f610(s7);
+              s0 = peg$f718(s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -65618,11 +75139,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c311) {
+      if (s1.toLowerCase() === peg$c341) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e335); }
+        if (peg$silentFails === 0) { peg$fail(peg$e367); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -65646,7 +75167,7 @@ function peg$parse(input, options) {
           s4 = peg$parseTypeArgFieldName();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f611(s4);
+            s0 = peg$f719(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -65667,11 +75188,11 @@ function peg$parse(input, options) {
           s3 = peg$currPos;
           peg$silentFails++;
           s4 = input.charAt(peg$currPos);
-          if (peg$r23.test(s4)) {
+          if (peg$r25.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e336); }
+            if (peg$silentFails === 0) { peg$fail(peg$e368); }
           }
           peg$silentFails--;
           if (s4 !== peg$FAILED) {
@@ -65684,7 +75205,7 @@ function peg$parse(input, options) {
             s4 = peg$parseColumnDataType();
             if (s4 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f612(s1, s4);
+              s0 = peg$f720(s1, s4);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -65702,37 +75223,37 @@ function peg$parse(input, options) {
           s1 = peg$currPos;
           s2 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 39) {
-            s3 = peg$c108;
+            s3 = peg$c99;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e113); }
+            if (peg$silentFails === 0) { peg$fail(peg$e104); }
           }
           if (s3 !== peg$FAILED) {
             s4 = [];
             s5 = input.charAt(peg$currPos);
-            if (peg$r5.test(s5)) {
+            if (peg$r8.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e178); }
+              if (peg$silentFails === 0) { peg$fail(peg$e219); }
             }
             while (s5 !== peg$FAILED) {
               s4.push(s5);
               s5 = input.charAt(peg$currPos);
-              if (peg$r5.test(s5)) {
+              if (peg$r8.test(s5)) {
                 peg$currPos++;
               } else {
                 s5 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e178); }
+                if (peg$silentFails === 0) { peg$fail(peg$e219); }
               }
             }
             if (input.charCodeAt(peg$currPos) === 39) {
-              s5 = peg$c108;
+              s5 = peg$c99;
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e113); }
+              if (peg$silentFails === 0) { peg$fail(peg$e104); }
             }
             if (s5 !== peg$FAILED) {
               s3 = [s3, s4, s5];
@@ -65752,7 +75273,7 @@ function peg$parse(input, options) {
           }
           if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
-            s1 = peg$f613(s1);
+            s1 = peg$f721(s1);
           }
           s0 = s1;
           if (s0 === peg$FAILED) {
@@ -65760,11 +75281,11 @@ function peg$parse(input, options) {
             s1 = peg$currPos;
             s2 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 45) {
-              s3 = peg$c273;
+              s3 = peg$c303;
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e293); }
+              if (peg$silentFails === 0) { peg$fail(peg$e325); }
             }
             if (s3 === peg$FAILED) {
               s3 = null;
@@ -65794,11 +75315,11 @@ function peg$parse(input, options) {
             if (s4 !== peg$FAILED) {
               s5 = peg$currPos;
               if (input.charCodeAt(peg$currPos) === 46) {
-                s6 = peg$c35;
+                s6 = peg$c39;
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e39); }
+                if (peg$silentFails === 0) { peg$fail(peg$e43); }
               }
               if (s6 !== peg$FAILED) {
                 s7 = [];
@@ -65841,7 +75362,7 @@ function peg$parse(input, options) {
             }
             if (s1 !== peg$FAILED) {
               peg$savedPos = s0;
-              s1 = peg$f614(s1);
+              s1 = peg$f722(s1);
             }
             s0 = s1;
             if (s0 === peg$FAILED) {
@@ -65849,11 +75370,11 @@ function peg$parse(input, options) {
               s1 = peg$currPos;
               s2 = peg$currPos;
               s3 = input.charAt(peg$currPos);
-              if (peg$r8.test(s3)) {
+              if (peg$r5.test(s3)) {
                 peg$currPos++;
               } else {
                 s3 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e184); }
+                if (peg$silentFails === 0) { peg$fail(peg$e129); }
               }
               if (s3 !== peg$FAILED) {
                 s4 = [];
@@ -65888,18 +75409,18 @@ function peg$parse(input, options) {
               if (s1 !== peg$FAILED) {
                 s2 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 61) {
-                  s3 = peg$c62;
+                  s3 = peg$c66;
                   peg$currPos++;
                 } else {
                   s3 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e67); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e71); }
                 }
                 if (s3 !== peg$FAILED) {
                   s4 = peg$parse_();
                   s5 = peg$parseTernaryExpr();
                   if (s5 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f615(s1, s5);
+                    s0 = peg$f723(s1, s5);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -65917,7 +75438,7 @@ function peg$parse(input, options) {
                 s1 = peg$parseColumnDataType();
                 if (s1 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s1 = peg$f616(s1);
+                  s1 = peg$f724(s1);
                 }
                 s0 = s1;
                 if (s0 === peg$FAILED) {
@@ -65925,21 +75446,21 @@ function peg$parse(input, options) {
                   s1 = peg$currPos;
                   s2 = [];
                   s3 = input.charAt(peg$currPos);
-                  if (peg$r24.test(s3)) {
+                  if (peg$r26.test(s3)) {
                     peg$currPos++;
                   } else {
                     s3 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e337); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e369); }
                   }
                   if (s3 !== peg$FAILED) {
                     while (s3 !== peg$FAILED) {
                       s2.push(s3);
                       s3 = input.charAt(peg$currPos);
-                      if (peg$r24.test(s3)) {
+                      if (peg$r26.test(s3)) {
                         peg$currPos++;
                       } else {
                         s3 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e337); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e369); }
                       }
                     }
                   } else {
@@ -65952,7 +75473,7 @@ function peg$parse(input, options) {
                   }
                   if (s1 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s1 = peg$f617(s1);
+                    s1 = peg$f725(s1);
                   }
                   s0 = s1;
                 }
@@ -65971,7 +75492,7 @@ function peg$parse(input, options) {
   function peg$parseTypeArgFieldName() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 351;
+    const key = peg$currPos * 508 + 393;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -65987,11 +75508,11 @@ function peg$parse(input, options) {
       s3 = [];
       s4 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 46) {
-        s5 = peg$c35;
+        s5 = peg$c39;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parseTypeArgFieldPart();
@@ -66010,11 +75531,11 @@ function peg$parse(input, options) {
         s3.push(s4);
         s4 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 46) {
-          s5 = peg$c35;
+          s5 = peg$c39;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e39); }
+          if (peg$silentFails === 0) { peg$fail(peg$e43); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parseTypeArgFieldPart();
@@ -66038,7 +75559,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f618(s1);
+      s1 = peg$f726(s1);
     }
     s0 = s1;
 
@@ -66050,7 +75571,7 @@ function peg$parse(input, options) {
   function peg$parseTypeArgFieldPart() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 352;
+    const key = peg$currPos * 508 + 394;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -66061,30 +75582,30 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 96) {
-      s1 = peg$c219;
+      s1 = peg$c124;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e231); }
+      if (peg$silentFails === 0) { peg$fail(peg$e133); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
       s3 = input.charAt(peg$currPos);
-      if (peg$r11.test(s3)) {
+      if (peg$r13.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e232); }
+        if (peg$silentFails === 0) { peg$fail(peg$e266); }
       }
       if (s3 !== peg$FAILED) {
         while (s3 !== peg$FAILED) {
           s2.push(s3);
           s3 = input.charAt(peg$currPos);
-          if (peg$r11.test(s3)) {
+          if (peg$r13.test(s3)) {
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e232); }
+            if (peg$silentFails === 0) { peg$fail(peg$e266); }
           }
         }
       } else {
@@ -66092,11 +75613,11 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         if (input.charCodeAt(peg$currPos) === 96) {
-          s3 = peg$c219;
+          s3 = peg$c124;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e231); }
+          if (peg$silentFails === 0) { peg$fail(peg$e133); }
         }
         if (s3 !== peg$FAILED) {
           s1 = [s1, s2, s3];
@@ -66116,30 +75637,30 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 34) {
-        s1 = peg$c255;
+        s1 = peg$c285;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e274); }
+        if (peg$silentFails === 0) { peg$fail(peg$e306); }
       }
       if (s1 !== peg$FAILED) {
         s2 = [];
         s3 = input.charAt(peg$currPos);
-        if (peg$r22.test(s3)) {
+        if (peg$r24.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e331); }
+          if (peg$silentFails === 0) { peg$fail(peg$e363); }
         }
         if (s3 !== peg$FAILED) {
           while (s3 !== peg$FAILED) {
             s2.push(s3);
             s3 = input.charAt(peg$currPos);
-            if (peg$r22.test(s3)) {
+            if (peg$r24.test(s3)) {
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e331); }
+              if (peg$silentFails === 0) { peg$fail(peg$e363); }
             }
           }
         } else {
@@ -66147,11 +75668,11 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           if (input.charCodeAt(peg$currPos) === 34) {
-            s3 = peg$c255;
+            s3 = peg$c285;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e274); }
+            if (peg$silentFails === 0) { peg$fail(peg$e306); }
           }
           if (s3 !== peg$FAILED) {
             s1 = [s1, s2, s3];
@@ -66171,29 +75692,29 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.charAt(peg$currPos);
-        if (peg$r25.test(s1)) {
+        if (peg$r27.test(s1)) {
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e338); }
+          if (peg$silentFails === 0) { peg$fail(peg$e370); }
         }
         if (s1 !== peg$FAILED) {
           s2 = [];
           s3 = input.charAt(peg$currPos);
-          if (peg$r26.test(s3)) {
+          if (peg$r28.test(s3)) {
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e339); }
+            if (peg$silentFails === 0) { peg$fail(peg$e371); }
           }
           while (s3 !== peg$FAILED) {
             s2.push(s3);
             s3 = input.charAt(peg$currPos);
-            if (peg$r26.test(s3)) {
+            if (peg$r28.test(s3)) {
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e339); }
+              if (peg$silentFails === 0) { peg$fail(peg$e371); }
             }
           }
           s1 = [s1, s2];
@@ -66213,7 +75734,7 @@ function peg$parse(input, options) {
   function peg$parseClickHouseType() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 353;
+    const key = peg$currPos * 508 + 395;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -66226,37 +75747,37 @@ function peg$parse(input, options) {
     s1 = peg$parseMultiWordType();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f619(s1);
+      s1 = peg$f727(s1);
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 96) {
-        s1 = peg$c219;
+        s1 = peg$c124;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e231); }
+        if (peg$silentFails === 0) { peg$fail(peg$e133); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
         s3 = [];
         s4 = input.charAt(peg$currPos);
-        if (peg$r11.test(s4)) {
+        if (peg$r13.test(s4)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e232); }
+          if (peg$silentFails === 0) { peg$fail(peg$e266); }
         }
         if (s4 !== peg$FAILED) {
           while (s4 !== peg$FAILED) {
             s3.push(s4);
             s4 = input.charAt(peg$currPos);
-            if (peg$r11.test(s4)) {
+            if (peg$r13.test(s4)) {
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e232); }
+              if (peg$silentFails === 0) { peg$fail(peg$e266); }
             }
           }
         } else {
@@ -66269,15 +75790,15 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           if (input.charCodeAt(peg$currPos) === 96) {
-            s3 = peg$c219;
+            s3 = peg$c124;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e231); }
+            if (peg$silentFails === 0) { peg$fail(peg$e133); }
           }
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f620(s2);
+            s0 = peg$f728(s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -66293,31 +75814,31 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 34) {
-          s1 = peg$c255;
+          s1 = peg$c285;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e274); }
+          if (peg$silentFails === 0) { peg$fail(peg$e306); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
           s3 = [];
           s4 = input.charAt(peg$currPos);
-          if (peg$r22.test(s4)) {
+          if (peg$r24.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e331); }
+            if (peg$silentFails === 0) { peg$fail(peg$e363); }
           }
           if (s4 !== peg$FAILED) {
             while (s4 !== peg$FAILED) {
               s3.push(s4);
               s4 = input.charAt(peg$currPos);
-              if (peg$r22.test(s4)) {
+              if (peg$r24.test(s4)) {
                 peg$currPos++;
               } else {
                 s4 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e331); }
+                if (peg$silentFails === 0) { peg$fail(peg$e363); }
               }
             }
           } else {
@@ -66330,15 +75851,15 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 34) {
-              s3 = peg$c255;
+              s3 = peg$c285;
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e274); }
+              if (peg$silentFails === 0) { peg$fail(peg$e306); }
             }
             if (s3 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f621(s2);
+              s0 = peg$f729(s2);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -66356,11 +75877,11 @@ function peg$parse(input, options) {
           s1 = peg$currPos;
           s2 = peg$currPos;
           s3 = input.charAt(peg$currPos);
-          if (peg$r8.test(s3)) {
+          if (peg$r5.test(s3)) {
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e184); }
+            if (peg$silentFails === 0) { peg$fail(peg$e129); }
           }
           if (s3 !== peg$FAILED) {
             s4 = [];
@@ -66399,7 +75920,7 @@ function peg$parse(input, options) {
               s3 = null;
             }
             peg$savedPos = s0;
-            s0 = peg$f622(s1, s3);
+            s0 = peg$f730(s1, s3);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -66416,7 +75937,7 @@ function peg$parse(input, options) {
   function peg$parseClickHouseTypeArgs() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 354;
+    const key = peg$currPos * 508 + 396;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -66427,11 +75948,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
@@ -66441,15 +75962,15 @@ function peg$parse(input, options) {
         s3 = peg$parseClickHouseTypeArgPart();
       }
       if (input.charCodeAt(peg$currPos) === 41) {
-        s3 = peg$c22;
+        s3 = peg$c26;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e26); }
+        if (peg$silentFails === 0) { peg$fail(peg$e30); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f623(s2);
+        s0 = peg$f731(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -66467,7 +75988,7 @@ function peg$parse(input, options) {
   function peg$parseClickHouseTypeArgPart() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 355;
+    const key = peg$currPos * 508 + 397;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -66480,7 +76001,7 @@ function peg$parse(input, options) {
     s1 = peg$parseClickHouseTypeArgs();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f624(s1);
+      s1 = peg$f732(s1);
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
@@ -66488,37 +76009,37 @@ function peg$parse(input, options) {
       s1 = peg$currPos;
       s2 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 39) {
-        s3 = peg$c108;
+        s3 = peg$c99;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e113); }
+        if (peg$silentFails === 0) { peg$fail(peg$e104); }
       }
       if (s3 !== peg$FAILED) {
         s4 = [];
         s5 = input.charAt(peg$currPos);
-        if (peg$r5.test(s5)) {
+        if (peg$r8.test(s5)) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e178); }
+          if (peg$silentFails === 0) { peg$fail(peg$e219); }
         }
         while (s5 !== peg$FAILED) {
           s4.push(s5);
           s5 = input.charAt(peg$currPos);
-          if (peg$r5.test(s5)) {
+          if (peg$r8.test(s5)) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e178); }
+            if (peg$silentFails === 0) { peg$fail(peg$e219); }
           }
         }
         if (input.charCodeAt(peg$currPos) === 39) {
-          s5 = peg$c108;
+          s5 = peg$c99;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e113); }
+          if (peg$silentFails === 0) { peg$fail(peg$e104); }
         }
         if (s5 !== peg$FAILED) {
           s3 = [s3, s4, s5];
@@ -66538,7 +76059,7 @@ function peg$parse(input, options) {
       }
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f625(s1);
+        s1 = peg$f733(s1);
       }
       s0 = s1;
       if (s0 === peg$FAILED) {
@@ -66546,21 +76067,21 @@ function peg$parse(input, options) {
         s1 = peg$currPos;
         s2 = [];
         s3 = input.charAt(peg$currPos);
-        if (peg$r27.test(s3)) {
+        if (peg$r29.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e340); }
+          if (peg$silentFails === 0) { peg$fail(peg$e372); }
         }
         if (s3 !== peg$FAILED) {
           while (s3 !== peg$FAILED) {
             s2.push(s3);
             s3 = input.charAt(peg$currPos);
-            if (peg$r27.test(s3)) {
+            if (peg$r29.test(s3)) {
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e340); }
+              if (peg$silentFails === 0) { peg$fail(peg$e372); }
             }
           }
         } else {
@@ -66573,7 +76094,7 @@ function peg$parse(input, options) {
         }
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f626(s1);
+          s1 = peg$f734(s1);
         }
         s0 = s1;
       }
@@ -66587,7 +76108,7 @@ function peg$parse(input, options) {
   function peg$parsePrimaryBase() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 356;
+    const key = peg$currPos * 508 + 398;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -66605,7 +76126,7 @@ function peg$parse(input, options) {
         s3 = peg$parseTupleLiteral();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f627(s3);
+          s0 = peg$f735(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -66620,11 +76141,11 @@ function peg$parse(input, options) {
         if (s1 !== peg$FAILED) {
           s2 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 40) {
-            s3 = peg$c21;
+            s3 = peg$c25;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s3 !== peg$FAILED) {
             s4 = peg$parse_();
@@ -66632,15 +76153,15 @@ function peg$parse(input, options) {
             if (s5 !== peg$FAILED) {
               s6 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s7 = peg$c22;
+                s7 = peg$c26;
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s7 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f628(s5);
+                s0 = peg$f736(s5);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -66671,18 +76192,18 @@ function peg$parse(input, options) {
                   s3 = peg$currPos;
                   s4 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 46) {
-                    s5 = peg$c35;
+                    s5 = peg$c39;
                     peg$currPos++;
                   } else {
                     s5 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e39); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e43); }
                   }
                   if (s5 !== peg$FAILED) {
                     s6 = peg$parse_();
                     s7 = peg$parseColumnRefCont();
                     if (s7 !== peg$FAILED) {
                       peg$savedPos = s3;
-                      s3 = peg$f629(s1, s7);
+                      s3 = peg$f737(s1, s7);
                     } else {
                       peg$currPos = s3;
                       s3 = peg$FAILED;
@@ -66697,18 +76218,18 @@ function peg$parse(input, options) {
                       s3 = peg$currPos;
                       s4 = peg$parse_();
                       if (input.charCodeAt(peg$currPos) === 46) {
-                        s5 = peg$c35;
+                        s5 = peg$c39;
                         peg$currPos++;
                       } else {
                         s5 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e43); }
                       }
                       if (s5 !== peg$FAILED) {
                         s6 = peg$parse_();
                         s7 = peg$parseColumnRefCont();
                         if (s7 !== peg$FAILED) {
                           peg$savedPos = s3;
-                          s3 = peg$f629(s1, s7);
+                          s3 = peg$f737(s1, s7);
                         } else {
                           peg$currPos = s3;
                           s3 = peg$FAILED;
@@ -66723,7 +76244,7 @@ function peg$parse(input, options) {
                   }
                   if (s2 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f630(s1, s2);
+                    s0 = peg$f738(s1, s2);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -66775,11 +76296,11 @@ function peg$parse(input, options) {
                                                       s3 = peg$currPos;
                                                       s4 = peg$parse_();
                                                       if (input.charCodeAt(peg$currPos) === 91) {
-                                                        s5 = peg$c287;
+                                                        s5 = peg$c317;
                                                         peg$currPos++;
                                                       } else {
                                                         s5 = peg$FAILED;
-                                                        if (peg$silentFails === 0) { peg$fail(peg$e309); }
+                                                        if (peg$silentFails === 0) { peg$fail(peg$e341); }
                                                       }
                                                       if (s5 !== peg$FAILED) {
                                                         s4 = [s4, s5];
@@ -66797,7 +76318,7 @@ function peg$parse(input, options) {
                                                       }
                                                       if (s2 !== peg$FAILED) {
                                                         peg$savedPos = s0;
-                                                        s0 = peg$f631(s1);
+                                                        s0 = peg$f739(s1);
                                                       } else {
                                                         peg$currPos = s0;
                                                         s0 = peg$FAILED;
@@ -66813,7 +76334,7 @@ function peg$parse(input, options) {
                                                         s1 = peg$parseAliasName();
                                                         if (s1 !== peg$FAILED) {
                                                           peg$savedPos = s0;
-                                                          s1 = peg$f632(s1);
+                                                          s1 = peg$f740(s1);
                                                         }
                                                         s0 = s1;
                                                         if (s0 === peg$FAILED) {
@@ -66854,7 +76375,7 @@ function peg$parse(input, options) {
   function peg$parseMapLiteral() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 357;
+    const key = peg$currPos * 508 + 399;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -66865,24 +76386,24 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 123) {
-      s1 = peg$c172;
+      s1 = peg$c210;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e180); }
+      if (peg$silentFails === 0) { peg$fail(peg$e221); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 125) {
-        s3 = peg$c173;
+        s3 = peg$c211;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e182); }
+        if (peg$silentFails === 0) { peg$fail(peg$e223); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f633();
+        s0 = peg$f741();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -66894,11 +76415,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 123) {
-        s1 = peg$c172;
+        s1 = peg$c210;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e180); }
+        if (peg$silentFails === 0) { peg$fail(peg$e221); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
@@ -66908,11 +76429,11 @@ function peg$parse(input, options) {
           s5 = peg$currPos;
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s7 = peg$c15;
+            s7 = peg$c24;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$parse_();
@@ -66933,11 +76454,11 @@ function peg$parse(input, options) {
             s5 = peg$currPos;
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 44) {
-              s7 = peg$c15;
+              s7 = peg$c24;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e17); }
+              if (peg$silentFails === 0) { peg$fail(peg$e28); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
@@ -66956,15 +76477,15 @@ function peg$parse(input, options) {
           }
           s5 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 125) {
-            s6 = peg$c173;
+            s6 = peg$c211;
             peg$currPos++;
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e182); }
+            if (peg$silentFails === 0) { peg$fail(peg$e223); }
           }
           if (s6 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f634(s3, s4);
+            s0 = peg$f742(s3, s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -66987,7 +76508,7 @@ function peg$parse(input, options) {
   function peg$parseMapEntry() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 358;
+    const key = peg$currPos * 508 + 400;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -67001,18 +76522,18 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 58) {
-        s3 = peg$c263;
+        s3 = peg$c293;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e282); }
+        if (peg$silentFails === 0) { peg$fail(peg$e314); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$parseTernaryExpr();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f635(s1, s5);
+          s0 = peg$f743(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -67034,7 +76555,7 @@ function peg$parse(input, options) {
   function peg$parseMySQLGlobalVariable() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 359;
+    const key = peg$currPos * 508 + 401;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -67044,36 +76565,36 @@ function peg$parse(input, options) {
     }
 
     s0 = peg$currPos;
-    if (input.substr(peg$currPos, 2) === peg$c312) {
-      s1 = peg$c312;
+    if (input.substr(peg$currPos, 2) === peg$c342) {
+      s1 = peg$c342;
       peg$currPos += 2;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e341); }
+      if (peg$silentFails === 0) { peg$fail(peg$e373); }
     }
     if (s1 !== peg$FAILED) {
-      if (input.substr(peg$currPos, 8) === peg$c313) {
-        s2 = peg$c313;
+      if (input.substr(peg$currPos, 8) === peg$c343) {
+        s2 = peg$c343;
         peg$currPos += 8;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e342); }
+        if (peg$silentFails === 0) { peg$fail(peg$e374); }
       }
       if (s2 === peg$FAILED) {
-        if (input.substr(peg$currPos, 7) === peg$c314) {
-          s2 = peg$c314;
+        if (input.substr(peg$currPos, 7) === peg$c344) {
+          s2 = peg$c344;
           peg$currPos += 7;
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e343); }
+          if (peg$silentFails === 0) { peg$fail(peg$e375); }
         }
         if (s2 === peg$FAILED) {
-          if (input.substr(peg$currPos, 6) === peg$c315) {
-            s2 = peg$c315;
+          if (input.substr(peg$currPos, 6) === peg$c345) {
+            s2 = peg$c345;
             peg$currPos += 6;
           } else {
             s2 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e344); }
+            if (peg$silentFails === 0) { peg$fail(peg$e376); }
           }
         }
       }
@@ -67110,7 +76631,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f636(s3);
+        s0 = peg$f744(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -67128,7 +76649,7 @@ function peg$parse(input, options) {
   function peg$parseParenGroup() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 360;
+    const key = peg$currPos * 508 + 402;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -67139,36 +76660,36 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 41) {
-        s3 = peg$c22;
+        s3 = peg$c26;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e26); }
+        if (peg$silentFails === 0) { peg$fail(peg$e30); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
-        if (input.substr(peg$currPos, 2) === peg$c241) {
-          s5 = peg$c241;
+        if (input.substr(peg$currPos, 2) === peg$c272) {
+          s5 = peg$c272;
           peg$currPos += 2;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e255); }
+          if (peg$silentFails === 0) { peg$fail(peg$e288); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           s7 = peg$parseExpression();
           if (s7 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f637(s7);
+            s0 = peg$f745(s7);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -67188,24 +76709,24 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 40) {
-        s1 = peg$c21;
+        s1 = peg$c25;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 41) {
-          s3 = peg$c22;
+          s3 = peg$c26;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f638();
+          s0 = peg$f746();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -67217,11 +76738,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 40) {
-          s1 = peg$c21;
+          s1 = peg$c25;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$parse_();
@@ -67233,11 +76754,11 @@ function peg$parse(input, options) {
             if (s4 === peg$FAILED) {
               s4 = peg$currPos;
               s5 = input.substr(peg$currPos, 7);
-              if (s5.toLowerCase() === peg$c227) {
+              if (s5.toLowerCase() === peg$c259) {
                 peg$currPos += (7);
               } else {
                 s5 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e241); }
+                if (peg$silentFails === 0) { peg$fail(peg$e275); }
               }
               if (s5 !== peg$FAILED) {
                 s6 = peg$currPos;
@@ -67281,15 +76802,15 @@ function peg$parse(input, options) {
             if (s4 !== peg$FAILED) {
               s5 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s6 = peg$c22;
+                s6 = peg$c26;
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s6 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f639(s2, s4, s5);
+                s0 = peg$f747(s2, s4, s5);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -67309,11 +76830,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 40) {
-            s1 = peg$c21;
+            s1 = peg$c25;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
@@ -67323,11 +76844,11 @@ function peg$parse(input, options) {
               s5 = peg$currPos;
               s6 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s7 = peg$c15;
+                s7 = peg$c24;
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s7 !== peg$FAILED) {
                 s8 = peg$parse_();
@@ -67348,11 +76869,11 @@ function peg$parse(input, options) {
                 s5 = peg$currPos;
                 s6 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s7 = peg$c15;
+                  s7 = peg$c24;
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s7 !== peg$FAILED) {
                   s8 = peg$parse_();
@@ -67371,27 +76892,27 @@ function peg$parse(input, options) {
               }
               s5 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s6 = peg$c22;
+                s6 = peg$c26;
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s6 !== peg$FAILED) {
                 s7 = peg$parse_();
-                if (input.substr(peg$currPos, 2) === peg$c241) {
-                  s8 = peg$c241;
+                if (input.substr(peg$currPos, 2) === peg$c272) {
+                  s8 = peg$c272;
                   peg$currPos += 2;
                 } else {
                   s8 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e255); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e288); }
                 }
                 if (s8 !== peg$FAILED) {
                   s9 = peg$parse_();
                   s10 = peg$parseExpression();
                   if (s10 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f640(s3, s4, s10);
+                    s0 = peg$f748(s3, s4, s10);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -67415,11 +76936,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 40) {
-              s1 = peg$c21;
+              s1 = peg$c25;
               peg$currPos++;
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$parse_();
@@ -67429,11 +76950,11 @@ function peg$parse(input, options) {
                 s5 = peg$currPos;
                 s6 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s7 = peg$c15;
+                  s7 = peg$c24;
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s7 !== peg$FAILED) {
                   s8 = peg$parse_();
@@ -67454,11 +76975,11 @@ function peg$parse(input, options) {
                   s5 = peg$currPos;
                   s6 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 44) {
-                    s7 = peg$c15;
+                    s7 = peg$c24;
                     peg$currPos++;
                   } else {
                     s7 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e28); }
                   }
                   if (s7 !== peg$FAILED) {
                     s8 = peg$parse_();
@@ -67478,11 +76999,11 @@ function peg$parse(input, options) {
                 s5 = peg$currPos;
                 s6 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s7 = peg$c15;
+                  s7 = peg$c24;
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s7 !== peg$FAILED) {
                   s6 = [s6, s7];
@@ -67496,15 +77017,15 @@ function peg$parse(input, options) {
                 }
                 s6 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 41) {
-                  s7 = peg$c22;
+                  s7 = peg$c26;
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
                 if (s7 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f641(s2, s3, s4, s5, s6);
+                  s0 = peg$f749(s2, s3, s4, s5, s6);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -67530,7 +77051,7 @@ function peg$parse(input, options) {
   function peg$parseTupleLiteral() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 361;
+    const key = peg$currPos * 508 + 403;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -67541,11 +77062,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c25;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
@@ -67553,24 +77074,24 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 41) {
-            s7 = peg$c22;
+            s7 = peg$c26;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e26); }
+            if (peg$silentFails === 0) { peg$fail(peg$e30); }
           }
           if (s7 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f642(s3);
+            s0 = peg$f750(s3);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -67590,11 +77111,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 40) {
-        s1 = peg$c21;
+        s1 = peg$c25;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
@@ -67602,11 +77123,11 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s5 = peg$c15;
+            s5 = peg$c24;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
@@ -67614,26 +77135,26 @@ function peg$parse(input, options) {
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s9 = peg$c15;
+                s9 = peg$c24;
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s9 === peg$FAILED) {
                 s9 = null;
               }
               s10 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s11 = peg$c22;
+                s11 = peg$c26;
                 peg$currPos++;
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s11 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f643(s3, s7);
+                s0 = peg$f751(s3, s7);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -67664,7 +77185,7 @@ function peg$parse(input, options) {
   function peg$parseArrayLiteral() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 362;
+    const key = peg$currPos * 508 + 404;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -67675,24 +77196,24 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 91) {
-      s1 = peg$c287;
+      s1 = peg$c317;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e309); }
+      if (peg$silentFails === 0) { peg$fail(peg$e341); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 93) {
-        s3 = peg$c288;
+        s3 = peg$c318;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e310); }
+        if (peg$silentFails === 0) { peg$fail(peg$e342); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f644();
+        s0 = peg$f752();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -67704,11 +77225,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 91) {
-        s1 = peg$c287;
+        s1 = peg$c317;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e309); }
+        if (peg$silentFails === 0) { peg$fail(peg$e341); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
@@ -67716,15 +77237,15 @@ function peg$parse(input, options) {
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 93) {
-            s5 = peg$c288;
+            s5 = peg$c318;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e310); }
+            if (peg$silentFails === 0) { peg$fail(peg$e342); }
           }
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f645(s2, s3, s4);
+            s0 = peg$f753(s2, s3, s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -67747,7 +77268,7 @@ function peg$parse(input, options) {
   function peg$parseQueryParam() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 363;
+    const key = peg$currPos * 508 + 405;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -67758,22 +77279,22 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 123) {
-      s1 = peg$c172;
+      s1 = peg$c210;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e180); }
+      if (peg$silentFails === 0) { peg$fail(peg$e221); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       s3 = peg$currPos;
       s4 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 36) {
-        s5 = peg$c316;
+        s5 = peg$c346;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e345); }
+        if (peg$silentFails === 0) { peg$fail(peg$e377); }
       }
       if (s5 !== peg$FAILED) {
         s6 = [];
@@ -67812,11 +77333,11 @@ function peg$parse(input, options) {
       if (s4 === peg$FAILED) {
         s4 = peg$currPos;
         s5 = input.charAt(peg$currPos);
-        if (peg$r8.test(s5)) {
+        if (peg$r5.test(s5)) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e184); }
+          if (peg$silentFails === 0) { peg$fail(peg$e129); }
         }
         if (s5 !== peg$FAILED) {
           s6 = [];
@@ -67852,32 +77373,32 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 58) {
-          s5 = peg$c263;
+          s5 = peg$c293;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e282); }
+          if (peg$silentFails === 0) { peg$fail(peg$e314); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           s7 = peg$currPos;
           s8 = [];
           s9 = input.charAt(peg$currPos);
-          if (peg$r7.test(s9)) {
+          if (peg$r10.test(s9)) {
             peg$currPos++;
           } else {
             s9 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e181); }
+            if (peg$silentFails === 0) { peg$fail(peg$e222); }
           }
           if (s9 !== peg$FAILED) {
             while (s9 !== peg$FAILED) {
               s8.push(s9);
               s9 = input.charAt(peg$currPos);
-              if (peg$r7.test(s9)) {
+              if (peg$r10.test(s9)) {
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e181); }
+                if (peg$silentFails === 0) { peg$fail(peg$e222); }
               }
             }
           } else {
@@ -67890,15 +77411,15 @@ function peg$parse(input, options) {
           }
           if (s7 !== peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 125) {
-              s8 = peg$c173;
+              s8 = peg$c211;
               peg$currPos++;
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e182); }
+              if (peg$silentFails === 0) { peg$fail(peg$e223); }
             }
             if (s8 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f646(s3, s7);
+              s0 = peg$f754(s3, s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -67928,7 +77449,7 @@ function peg$parse(input, options) {
   function peg$parseHeredocLiteral() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 364;
+    const key = peg$currPos * 508 + 406;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -67939,43 +77460,43 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 36) {
-      s1 = peg$c316;
+      s1 = peg$c346;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e345); }
+      if (peg$silentFails === 0) { peg$fail(peg$e377); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
       s3 = [];
       s4 = input.charAt(peg$currPos);
-      if (peg$r28.test(s4)) {
+      if (peg$r30.test(s4)) {
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e346); }
+        if (peg$silentFails === 0) { peg$fail(peg$e378); }
       }
       while (s4 !== peg$FAILED) {
         s3.push(s4);
         s4 = input.charAt(peg$currPos);
-        if (peg$r28.test(s4)) {
+        if (peg$r30.test(s4)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e346); }
+          if (peg$silentFails === 0) { peg$fail(peg$e378); }
         }
       }
       s2 = input.substring(s2, peg$currPos);
       if (input.charCodeAt(peg$currPos) === 36) {
-        s3 = peg$c316;
+        s3 = peg$c346;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e345); }
+        if (peg$silentFails === 0) { peg$fail(peg$e377); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f647(s2);
+        s0 = peg$f755(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -67993,7 +77514,7 @@ function peg$parse(input, options) {
   function peg$parseBoolLiteral() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 365;
+    const key = peg$currPos * 508 + 407;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -68004,11 +77525,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c317) {
+    if (s1.toLowerCase() === peg$c347) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e347); }
+      if (peg$silentFails === 0) { peg$fail(peg$e379); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -68029,7 +77550,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f648();
+        s0 = peg$f756();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -68041,11 +77562,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c318) {
+      if (s1.toLowerCase() === peg$c348) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e348); }
+        if (peg$silentFails === 0) { peg$fail(peg$e380); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -68066,7 +77587,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f649();
+          s0 = peg$f757();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -68085,7 +77606,7 @@ function peg$parse(input, options) {
   function peg$parseNullLiteral() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 366;
+    const key = peg$currPos * 508 + 408;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -68096,11 +77617,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c44) {
+    if (s1.toLowerCase() === peg$c48) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e48); }
+      if (peg$silentFails === 0) { peg$fail(peg$e52); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -68121,7 +77642,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f650();
+        s0 = peg$f758();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -68139,7 +77660,7 @@ function peg$parse(input, options) {
   function peg$parseBinaryStringLiteral() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 367;
+    const key = peg$currPos * 508 + 409;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -68150,51 +77671,51 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.charAt(peg$currPos);
-    if (peg$r29.test(s1)) {
+    if (peg$r31.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e349); }
+      if (peg$silentFails === 0) { peg$fail(peg$e381); }
     }
     if (s1 !== peg$FAILED) {
       if (input.charCodeAt(peg$currPos) === 39) {
-        s2 = peg$c108;
+        s2 = peg$c99;
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e113); }
+        if (peg$silentFails === 0) { peg$fail(peg$e104); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
         s4 = [];
         s5 = input.charAt(peg$currPos);
-        if (peg$r30.test(s5)) {
+        if (peg$r32.test(s5)) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e350); }
+          if (peg$silentFails === 0) { peg$fail(peg$e382); }
         }
         while (s5 !== peg$FAILED) {
           s4.push(s5);
           s5 = input.charAt(peg$currPos);
-          if (peg$r30.test(s5)) {
+          if (peg$r32.test(s5)) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e350); }
+            if (peg$silentFails === 0) { peg$fail(peg$e382); }
           }
         }
         s3 = input.substring(s3, peg$currPos);
         if (input.charCodeAt(peg$currPos) === 39) {
-          s4 = peg$c108;
+          s4 = peg$c99;
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e113); }
+          if (peg$silentFails === 0) { peg$fail(peg$e104); }
         }
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f651(s3);
+          s0 = peg$f759(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -68216,7 +77737,7 @@ function peg$parse(input, options) {
   function peg$parseHexStringLiteral() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 368;
+    const key = peg$currPos * 508 + 410;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -68227,51 +77748,51 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.charAt(peg$currPos);
-    if (peg$r31.test(s1)) {
+    if (peg$r33.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e351); }
+      if (peg$silentFails === 0) { peg$fail(peg$e383); }
     }
     if (s1 !== peg$FAILED) {
       if (input.charCodeAt(peg$currPos) === 39) {
-        s2 = peg$c108;
+        s2 = peg$c99;
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e113); }
+        if (peg$silentFails === 0) { peg$fail(peg$e104); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$currPos;
         s4 = [];
         s5 = input.charAt(peg$currPos);
-        if (peg$r32.test(s5)) {
+        if (peg$r34.test(s5)) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e352); }
+          if (peg$silentFails === 0) { peg$fail(peg$e384); }
         }
         while (s5 !== peg$FAILED) {
           s4.push(s5);
           s5 = input.charAt(peg$currPos);
-          if (peg$r32.test(s5)) {
+          if (peg$r34.test(s5)) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e352); }
+            if (peg$silentFails === 0) { peg$fail(peg$e384); }
           }
         }
         s3 = input.substring(s3, peg$currPos);
         if (input.charCodeAt(peg$currPos) === 39) {
-          s4 = peg$c108;
+          s4 = peg$c99;
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e113); }
+          if (peg$silentFails === 0) { peg$fail(peg$e104); }
         }
         if (s4 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f652(s3);
+          s0 = peg$f760(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -68293,7 +77814,7 @@ function peg$parse(input, options) {
   function peg$parseHexLiteral() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 369;
+    const key = peg$currPos * 508 + 411;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -68304,32 +77825,32 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c319) {
+    if (s1.toLowerCase() === peg$c349) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e353); }
+      if (peg$silentFails === 0) { peg$fail(peg$e385); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
       s3 = peg$currPos;
       s4 = [];
       s5 = input.charAt(peg$currPos);
-      if (peg$r32.test(s5)) {
+      if (peg$r34.test(s5)) {
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e352); }
+        if (peg$silentFails === 0) { peg$fail(peg$e384); }
       }
       if (s5 !== peg$FAILED) {
         while (s5 !== peg$FAILED) {
           s4.push(s5);
           s5 = input.charAt(peg$currPos);
-          if (peg$r32.test(s5)) {
+          if (peg$r34.test(s5)) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e352); }
+            if (peg$silentFails === 0) { peg$fail(peg$e384); }
           }
         }
       } else {
@@ -68339,30 +77860,30 @@ function peg$parse(input, options) {
         s5 = [];
         s6 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 95) {
-          s7 = peg$c212;
+          s7 = peg$c245;
           peg$currPos++;
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e222); }
+          if (peg$silentFails === 0) { peg$fail(peg$e257); }
         }
         if (s7 !== peg$FAILED) {
           s8 = [];
           s9 = input.charAt(peg$currPos);
-          if (peg$r32.test(s9)) {
+          if (peg$r34.test(s9)) {
             peg$currPos++;
           } else {
             s9 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e352); }
+            if (peg$silentFails === 0) { peg$fail(peg$e384); }
           }
           if (s9 !== peg$FAILED) {
             while (s9 !== peg$FAILED) {
               s8.push(s9);
               s9 = input.charAt(peg$currPos);
-              if (peg$r32.test(s9)) {
+              if (peg$r34.test(s9)) {
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                if (peg$silentFails === 0) { peg$fail(peg$e384); }
               }
             }
           } else {
@@ -68383,30 +77904,30 @@ function peg$parse(input, options) {
           s5.push(s6);
           s6 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 95) {
-            s7 = peg$c212;
+            s7 = peg$c245;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e222); }
+            if (peg$silentFails === 0) { peg$fail(peg$e257); }
           }
           if (s7 !== peg$FAILED) {
             s8 = [];
             s9 = input.charAt(peg$currPos);
-            if (peg$r32.test(s9)) {
+            if (peg$r34.test(s9)) {
               peg$currPos++;
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e352); }
+              if (peg$silentFails === 0) { peg$fail(peg$e384); }
             }
             if (s9 !== peg$FAILED) {
               while (s9 !== peg$FAILED) {
                 s8.push(s9);
                 s9 = input.charAt(peg$currPos);
-                if (peg$r32.test(s9)) {
+                if (peg$r34.test(s9)) {
                   peg$currPos++;
                 } else {
                   s9 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e384); }
                 }
               }
             } else {
@@ -68437,32 +77958,32 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         if (input.charCodeAt(peg$currPos) === 46) {
-          s3 = peg$c35;
+          s3 = peg$c39;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e39); }
+          if (peg$silentFails === 0) { peg$fail(peg$e43); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$currPos;
           s5 = peg$currPos;
           s6 = [];
           s7 = input.charAt(peg$currPos);
-          if (peg$r32.test(s7)) {
+          if (peg$r34.test(s7)) {
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e352); }
+            if (peg$silentFails === 0) { peg$fail(peg$e384); }
           }
           if (s7 !== peg$FAILED) {
             while (s7 !== peg$FAILED) {
               s6.push(s7);
               s7 = input.charAt(peg$currPos);
-              if (peg$r32.test(s7)) {
+              if (peg$r34.test(s7)) {
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                if (peg$silentFails === 0) { peg$fail(peg$e384); }
               }
             }
           } else {
@@ -68472,30 +77993,30 @@ function peg$parse(input, options) {
             s7 = [];
             s8 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 95) {
-              s9 = peg$c212;
+              s9 = peg$c245;
               peg$currPos++;
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e222); }
+              if (peg$silentFails === 0) { peg$fail(peg$e257); }
             }
             if (s9 !== peg$FAILED) {
               s10 = [];
               s11 = input.charAt(peg$currPos);
-              if (peg$r32.test(s11)) {
+              if (peg$r34.test(s11)) {
                 peg$currPos++;
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                if (peg$silentFails === 0) { peg$fail(peg$e384); }
               }
               if (s11 !== peg$FAILED) {
                 while (s11 !== peg$FAILED) {
                   s10.push(s11);
                   s11 = input.charAt(peg$currPos);
-                  if (peg$r32.test(s11)) {
+                  if (peg$r34.test(s11)) {
                     peg$currPos++;
                   } else {
                     s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e384); }
                   }
                 }
               } else {
@@ -68516,30 +78037,30 @@ function peg$parse(input, options) {
               s7.push(s8);
               s8 = peg$currPos;
               if (input.charCodeAt(peg$currPos) === 95) {
-                s9 = peg$c212;
+                s9 = peg$c245;
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e222); }
+                if (peg$silentFails === 0) { peg$fail(peg$e257); }
               }
               if (s9 !== peg$FAILED) {
                 s10 = [];
                 s11 = input.charAt(peg$currPos);
-                if (peg$r32.test(s11)) {
+                if (peg$r34.test(s11)) {
                   peg$currPos++;
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e384); }
                 }
                 if (s11 !== peg$FAILED) {
                   while (s11 !== peg$FAILED) {
                     s10.push(s11);
                     s11 = input.charAt(peg$currPos);
-                    if (peg$r32.test(s11)) {
+                    if (peg$r34.test(s11)) {
                       peg$currPos++;
                     } else {
                       s11 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e384); }
                     }
                   }
                 } else {
@@ -68589,7 +78110,7 @@ function peg$parse(input, options) {
           }
           if (s6 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f653(s2, s4, s5);
+            s0 = peg$f761(s2, s4, s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -68609,32 +78130,32 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 2);
-      if (s1.toLowerCase() === peg$c319) {
+      if (s1.toLowerCase() === peg$c349) {
         peg$currPos += (2);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e353); }
+        if (peg$silentFails === 0) { peg$fail(peg$e385); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
         s3 = peg$currPos;
         s4 = [];
         s5 = input.charAt(peg$currPos);
-        if (peg$r32.test(s5)) {
+        if (peg$r34.test(s5)) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e352); }
+          if (peg$silentFails === 0) { peg$fail(peg$e384); }
         }
         if (s5 !== peg$FAILED) {
           while (s5 !== peg$FAILED) {
             s4.push(s5);
             s5 = input.charAt(peg$currPos);
-            if (peg$r32.test(s5)) {
+            if (peg$r34.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e352); }
+              if (peg$silentFails === 0) { peg$fail(peg$e384); }
             }
           }
         } else {
@@ -68644,30 +78165,30 @@ function peg$parse(input, options) {
           s5 = [];
           s6 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 95) {
-            s7 = peg$c212;
+            s7 = peg$c245;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e222); }
+            if (peg$silentFails === 0) { peg$fail(peg$e257); }
           }
           if (s7 !== peg$FAILED) {
             s8 = [];
             s9 = input.charAt(peg$currPos);
-            if (peg$r32.test(s9)) {
+            if (peg$r34.test(s9)) {
               peg$currPos++;
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e352); }
+              if (peg$silentFails === 0) { peg$fail(peg$e384); }
             }
             if (s9 !== peg$FAILED) {
               while (s9 !== peg$FAILED) {
                 s8.push(s9);
                 s9 = input.charAt(peg$currPos);
-                if (peg$r32.test(s9)) {
+                if (peg$r34.test(s9)) {
                   peg$currPos++;
                 } else {
                   s9 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e384); }
                 }
               }
             } else {
@@ -68688,30 +78209,30 @@ function peg$parse(input, options) {
             s5.push(s6);
             s6 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 95) {
-              s7 = peg$c212;
+              s7 = peg$c245;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e222); }
+              if (peg$silentFails === 0) { peg$fail(peg$e257); }
             }
             if (s7 !== peg$FAILED) {
               s8 = [];
               s9 = input.charAt(peg$currPos);
-              if (peg$r32.test(s9)) {
+              if (peg$r34.test(s9)) {
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                if (peg$silentFails === 0) { peg$fail(peg$e384); }
               }
               if (s9 !== peg$FAILED) {
                 while (s9 !== peg$FAILED) {
                   s8.push(s9);
                   s9 = input.charAt(peg$currPos);
-                  if (peg$r32.test(s9)) {
+                  if (peg$r34.test(s9)) {
                     peg$currPos++;
                   } else {
                     s9 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e384); }
                   }
                 }
               } else {
@@ -68763,7 +78284,7 @@ function peg$parse(input, options) {
           }
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f654(s2, s3);
+            s0 = peg$f762(s2, s3);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -68786,7 +78307,7 @@ function peg$parse(input, options) {
   function peg$parseHexExponentPart() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 370;
+    const key = peg$currPos * 508 + 412;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -68797,20 +78318,20 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.charAt(peg$currPos);
-    if (peg$r33.test(s1)) {
+    if (peg$r35.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e354); }
+      if (peg$silentFails === 0) { peg$fail(peg$e386); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
       s3 = input.charAt(peg$currPos);
-      if (peg$r16.test(s3)) {
+      if (peg$r18.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e265); }
+        if (peg$silentFails === 0) { peg$fail(peg$e297); }
       }
       if (s3 === peg$FAILED) {
         s3 = null;
@@ -68844,11 +78365,11 @@ function peg$parse(input, options) {
         s6 = [];
         s7 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 95) {
-          s8 = peg$c212;
+          s8 = peg$c245;
           peg$currPos++;
         } else {
           s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e222); }
+          if (peg$silentFails === 0) { peg$fail(peg$e257); }
         }
         if (s8 !== peg$FAILED) {
           s9 = [];
@@ -68888,11 +78409,11 @@ function peg$parse(input, options) {
           s6.push(s7);
           s7 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 95) {
-            s8 = peg$c212;
+            s8 = peg$c245;
             peg$currPos++;
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e222); }
+            if (peg$silentFails === 0) { peg$fail(peg$e257); }
           }
           if (s8 !== peg$FAILED) {
             s9 = [];
@@ -68942,7 +78463,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f655(s2, s3);
+        s0 = peg$f763(s2, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -68960,7 +78481,7 @@ function peg$parse(input, options) {
   function peg$parseBinaryNumLiteral() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 371;
+    const key = peg$currPos * 508 + 413;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -68971,32 +78492,32 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c320) {
+    if (s1.toLowerCase() === peg$c350) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e355); }
+      if (peg$silentFails === 0) { peg$fail(peg$e387); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
       s3 = peg$currPos;
       s4 = [];
       s5 = input.charAt(peg$currPos);
-      if (peg$r30.test(s5)) {
+      if (peg$r32.test(s5)) {
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e350); }
+        if (peg$silentFails === 0) { peg$fail(peg$e382); }
       }
       if (s5 !== peg$FAILED) {
         while (s5 !== peg$FAILED) {
           s4.push(s5);
           s5 = input.charAt(peg$currPos);
-          if (peg$r30.test(s5)) {
+          if (peg$r32.test(s5)) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e350); }
+            if (peg$silentFails === 0) { peg$fail(peg$e382); }
           }
         }
       } else {
@@ -69006,30 +78527,30 @@ function peg$parse(input, options) {
         s5 = [];
         s6 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 95) {
-          s7 = peg$c212;
+          s7 = peg$c245;
           peg$currPos++;
         } else {
           s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e222); }
+          if (peg$silentFails === 0) { peg$fail(peg$e257); }
         }
         if (s7 !== peg$FAILED) {
           s8 = [];
           s9 = input.charAt(peg$currPos);
-          if (peg$r30.test(s9)) {
+          if (peg$r32.test(s9)) {
             peg$currPos++;
           } else {
             s9 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e350); }
+            if (peg$silentFails === 0) { peg$fail(peg$e382); }
           }
           if (s9 !== peg$FAILED) {
             while (s9 !== peg$FAILED) {
               s8.push(s9);
               s9 = input.charAt(peg$currPos);
-              if (peg$r30.test(s9)) {
+              if (peg$r32.test(s9)) {
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e350); }
+                if (peg$silentFails === 0) { peg$fail(peg$e382); }
               }
             }
           } else {
@@ -69050,30 +78571,30 @@ function peg$parse(input, options) {
           s5.push(s6);
           s6 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 95) {
-            s7 = peg$c212;
+            s7 = peg$c245;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e222); }
+            if (peg$silentFails === 0) { peg$fail(peg$e257); }
           }
           if (s7 !== peg$FAILED) {
             s8 = [];
             s9 = input.charAt(peg$currPos);
-            if (peg$r30.test(s9)) {
+            if (peg$r32.test(s9)) {
               peg$currPos++;
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e350); }
+              if (peg$silentFails === 0) { peg$fail(peg$e382); }
             }
             if (s9 !== peg$FAILED) {
               while (s9 !== peg$FAILED) {
                 s8.push(s9);
                 s9 = input.charAt(peg$currPos);
-                if (peg$r30.test(s9)) {
+                if (peg$r32.test(s9)) {
                   peg$currPos++;
                 } else {
                   s9 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e350); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e382); }
                 }
               }
             } else {
@@ -69121,7 +78642,7 @@ function peg$parse(input, options) {
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f656(s2);
+          s0 = peg$f764(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -69143,7 +78664,7 @@ function peg$parse(input, options) {
   function peg$parseFloatLiteral() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 372;
+    const key = peg$currPos * 508 + 414;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -69154,11 +78675,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c321) {
+    if (s1.toLowerCase() === peg$c351) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e356); }
+      if (peg$silentFails === 0) { peg$fail(peg$e388); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -69179,7 +78700,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f657();
+        s0 = peg$f765();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -69191,11 +78712,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 3);
-      if (s1.toLowerCase() === peg$c322) {
+      if (s1.toLowerCase() === peg$c352) {
         peg$currPos += (3);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e357); }
+        if (peg$silentFails === 0) { peg$fail(peg$e389); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -69216,7 +78737,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f658();
+          s0 = peg$f766();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -69255,11 +78776,11 @@ function peg$parse(input, options) {
           s4 = [];
           s5 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 95) {
-            s6 = peg$c212;
+            s6 = peg$c245;
             peg$currPos++;
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e222); }
+            if (peg$silentFails === 0) { peg$fail(peg$e257); }
           }
           if (s6 !== peg$FAILED) {
             s7 = [];
@@ -69299,11 +78820,11 @@ function peg$parse(input, options) {
             s4.push(s5);
             s5 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 95) {
-              s6 = peg$c212;
+              s6 = peg$c245;
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e222); }
+              if (peg$silentFails === 0) { peg$fail(peg$e257); }
             }
             if (s6 !== peg$FAILED) {
               s7 = [];
@@ -69353,11 +78874,11 @@ function peg$parse(input, options) {
         }
         if (s1 !== peg$FAILED) {
           if (input.charCodeAt(peg$currPos) === 46) {
-            s2 = peg$c35;
+            s2 = peg$c39;
             peg$currPos++;
           } else {
             s2 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e39); }
+            if (peg$silentFails === 0) { peg$fail(peg$e43); }
           }
           if (s2 !== peg$FAILED) {
             s3 = peg$currPos;
@@ -69388,11 +78909,11 @@ function peg$parse(input, options) {
               s6 = [];
               s7 = peg$currPos;
               if (input.charCodeAt(peg$currPos) === 95) {
-                s8 = peg$c212;
+                s8 = peg$c245;
                 peg$currPos++;
               } else {
                 s8 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e222); }
+                if (peg$silentFails === 0) { peg$fail(peg$e257); }
               }
               if (s8 !== peg$FAILED) {
                 s9 = [];
@@ -69432,11 +78953,11 @@ function peg$parse(input, options) {
                 s6.push(s7);
                 s7 = peg$currPos;
                 if (input.charCodeAt(peg$currPos) === 95) {
-                  s8 = peg$c212;
+                  s8 = peg$c245;
                   peg$currPos++;
                 } else {
                   s8 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e222); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e257); }
                 }
                 if (s8 !== peg$FAILED) {
                   s9 = [];
@@ -69490,11 +79011,11 @@ function peg$parse(input, options) {
             s5 = peg$currPos;
             peg$silentFails++;
             s6 = input.charAt(peg$currPos);
-            if (peg$r8.test(s6)) {
+            if (peg$r5.test(s6)) {
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e184); }
+              if (peg$silentFails === 0) { peg$fail(peg$e129); }
             }
             peg$silentFails--;
             if (s6 === peg$FAILED) {
@@ -69505,7 +79026,7 @@ function peg$parse(input, options) {
             }
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f659(s1, s3, s4);
+              s0 = peg$f767(s1, s3, s4);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -69521,11 +79042,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 46) {
-            s1 = peg$c35;
+            s1 = peg$c39;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e39); }
+            if (peg$silentFails === 0) { peg$fail(peg$e43); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -69556,11 +79077,11 @@ function peg$parse(input, options) {
               s5 = [];
               s6 = peg$currPos;
               if (input.charCodeAt(peg$currPos) === 95) {
-                s7 = peg$c212;
+                s7 = peg$c245;
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e222); }
+                if (peg$silentFails === 0) { peg$fail(peg$e257); }
               }
               if (s7 !== peg$FAILED) {
                 s8 = [];
@@ -69600,11 +79121,11 @@ function peg$parse(input, options) {
                 s5.push(s6);
                 s6 = peg$currPos;
                 if (input.charCodeAt(peg$currPos) === 95) {
-                  s7 = peg$c212;
+                  s7 = peg$c245;
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e222); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e257); }
                 }
                 if (s7 !== peg$FAILED) {
                   s8 = [];
@@ -69660,11 +79181,11 @@ function peg$parse(input, options) {
               s4 = peg$currPos;
               peg$silentFails++;
               s5 = input.charAt(peg$currPos);
-              if (peg$r8.test(s5)) {
+              if (peg$r5.test(s5)) {
                 peg$currPos++;
               } else {
                 s5 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e184); }
+                if (peg$silentFails === 0) { peg$fail(peg$e129); }
               }
               peg$silentFails--;
               if (s5 === peg$FAILED) {
@@ -69675,7 +79196,7 @@ function peg$parse(input, options) {
               }
               if (s4 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f660(s2, s3);
+                s0 = peg$f768(s2, s3);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -69718,11 +79239,11 @@ function peg$parse(input, options) {
               s4 = [];
               s5 = peg$currPos;
               if (input.charCodeAt(peg$currPos) === 95) {
-                s6 = peg$c212;
+                s6 = peg$c245;
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e222); }
+                if (peg$silentFails === 0) { peg$fail(peg$e257); }
               }
               if (s6 !== peg$FAILED) {
                 s7 = [];
@@ -69762,11 +79283,11 @@ function peg$parse(input, options) {
                 s4.push(s5);
                 s5 = peg$currPos;
                 if (input.charCodeAt(peg$currPos) === 95) {
-                  s6 = peg$c212;
+                  s6 = peg$c245;
                   peg$currPos++;
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e222); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e257); }
                 }
                 if (s6 !== peg$FAILED) {
                   s7 = [];
@@ -69820,11 +79341,11 @@ function peg$parse(input, options) {
                 s3 = peg$currPos;
                 peg$silentFails++;
                 s4 = input.charAt(peg$currPos);
-                if (peg$r8.test(s4)) {
+                if (peg$r5.test(s4)) {
                   peg$currPos++;
                 } else {
                   s4 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e184); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e129); }
                 }
                 peg$silentFails--;
                 if (s4 === peg$FAILED) {
@@ -69835,7 +79356,7 @@ function peg$parse(input, options) {
                 }
                 if (s3 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f661(s1, s2);
+                  s0 = peg$f769(s1, s2);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -69861,7 +79382,7 @@ function peg$parse(input, options) {
   function peg$parseExponentPart() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 373;
+    const key = peg$currPos * 508 + 415;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -69872,20 +79393,20 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.charAt(peg$currPos);
-    if (peg$r15.test(s1)) {
+    if (peg$r17.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e264); }
+      if (peg$silentFails === 0) { peg$fail(peg$e296); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
       s3 = input.charAt(peg$currPos);
-      if (peg$r16.test(s3)) {
+      if (peg$r18.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e265); }
+        if (peg$silentFails === 0) { peg$fail(peg$e297); }
       }
       if (s3 === peg$FAILED) {
         s3 = null;
@@ -69919,11 +79440,11 @@ function peg$parse(input, options) {
         s6 = [];
         s7 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 95) {
-          s8 = peg$c212;
+          s8 = peg$c245;
           peg$currPos++;
         } else {
           s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e222); }
+          if (peg$silentFails === 0) { peg$fail(peg$e257); }
         }
         if (s8 !== peg$FAILED) {
           s9 = [];
@@ -69963,11 +79484,11 @@ function peg$parse(input, options) {
           s6.push(s7);
           s7 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 95) {
-            s8 = peg$c212;
+            s8 = peg$c245;
             peg$currPos++;
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e222); }
+            if (peg$silentFails === 0) { peg$fail(peg$e257); }
           }
           if (s8 !== peg$FAILED) {
             s9 = [];
@@ -70017,7 +79538,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f662(s1, s2, s3);
+        s0 = peg$f770(s1, s2, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -70035,7 +79556,7 @@ function peg$parse(input, options) {
   function peg$parseLambdaExprNoParens() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 374;
+    const key = peg$currPos * 508 + 416;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -70048,19 +79569,19 @@ function peg$parse(input, options) {
     s1 = peg$parseLambdaParamName();
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
-      if (input.substr(peg$currPos, 2) === peg$c241) {
-        s3 = peg$c241;
+      if (input.substr(peg$currPos, 2) === peg$c272) {
+        s3 = peg$c272;
         peg$currPos += 2;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e255); }
+        if (peg$silentFails === 0) { peg$fail(peg$e288); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$parseExpression();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f663(s1, s5);
+          s0 = peg$f771(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -70082,7 +79603,7 @@ function peg$parse(input, options) {
   function peg$parseCaseExpr() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
 
-    const key = peg$currPos * 466 + 375;
+    const key = peg$currPos * 508 + 417;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -70093,11 +79614,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c323) {
+    if (s1.toLowerCase() === peg$c353) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e358); }
+      if (peg$silentFails === 0) { peg$fail(peg$e390); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -70132,11 +79653,11 @@ function peg$parse(input, options) {
           s5 = peg$currPos;
           s6 = peg$parse_();
           s7 = input.substr(peg$currPos, 4);
-          if (s7.toLowerCase() === peg$c324) {
+          if (s7.toLowerCase() === peg$c354) {
             peg$currPos += (4);
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e359); }
+            if (peg$silentFails === 0) { peg$fail(peg$e391); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$currPos;
@@ -70178,11 +79699,11 @@ function peg$parse(input, options) {
           }
           s6 = peg$parse_();
           s7 = input.substr(peg$currPos, 3);
-          if (s7.toLowerCase() === peg$c325) {
+          if (s7.toLowerCase() === peg$c355) {
             peg$currPos += (3);
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e360); }
+            if (peg$silentFails === 0) { peg$fail(peg$e392); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$currPos;
@@ -70203,7 +79724,7 @@ function peg$parse(input, options) {
             }
             if (s8 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f664(s4, s5);
+              s0 = peg$f772(s4, s5);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -70227,11 +79748,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 4);
-      if (s1.toLowerCase() === peg$c323) {
+      if (s1.toLowerCase() === peg$c353) {
         peg$currPos += (4);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e358); }
+        if (peg$silentFails === 0) { peg$fail(peg$e390); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -70269,11 +79790,11 @@ function peg$parse(input, options) {
               s7 = peg$currPos;
               s8 = peg$parse_();
               s9 = input.substr(peg$currPos, 4);
-              if (s9.toLowerCase() === peg$c324) {
+              if (s9.toLowerCase() === peg$c354) {
                 peg$currPos += (4);
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e359); }
+                if (peg$silentFails === 0) { peg$fail(peg$e391); }
               }
               if (s9 !== peg$FAILED) {
                 s10 = peg$currPos;
@@ -70315,11 +79836,11 @@ function peg$parse(input, options) {
               }
               s8 = peg$parse_();
               s9 = input.substr(peg$currPos, 3);
-              if (s9.toLowerCase() === peg$c325) {
+              if (s9.toLowerCase() === peg$c355) {
                 peg$currPos += (3);
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e360); }
+                if (peg$silentFails === 0) { peg$fail(peg$e392); }
               }
               if (s9 !== peg$FAILED) {
                 s10 = peg$currPos;
@@ -70340,7 +79861,7 @@ function peg$parse(input, options) {
                 }
                 if (s10 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f665(s4, s6, s7);
+                  s0 = peg$f773(s4, s6, s7);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -70375,7 +79896,7 @@ function peg$parse(input, options) {
   function peg$parseCaseWhenBranch() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 376;
+    const key = peg$currPos * 508 + 418;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -70387,11 +79908,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 4);
-    if (s2.toLowerCase() === peg$c326) {
+    if (s2.toLowerCase() === peg$c356) {
       peg$currPos += (4);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e361); }
+      if (peg$silentFails === 0) { peg$fail(peg$e393); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$currPos;
@@ -70416,11 +79937,11 @@ function peg$parse(input, options) {
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           s7 = input.substr(peg$currPos, 4);
-          if (s7.toLowerCase() === peg$c327) {
+          if (s7.toLowerCase() === peg$c357) {
             peg$currPos += (4);
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e362); }
+            if (peg$silentFails === 0) { peg$fail(peg$e394); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$currPos;
@@ -70444,7 +79965,7 @@ function peg$parse(input, options) {
               s10 = peg$parseExpression();
               if (s10 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f666(s5, s10);
+                s0 = peg$f774(s5, s10);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -70478,7 +79999,7 @@ function peg$parse(input, options) {
   function peg$parseIntervalExpr() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 377;
+    const key = peg$currPos * 508 + 419;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -70489,11 +80010,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c192) {
+    if (s1.toLowerCase() === peg$c225) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e202); }
+      if (peg$silentFails === 0) { peg$fail(peg$e237); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -70520,7 +80041,7 @@ function peg$parse(input, options) {
           s6 = peg$parseIntervalUnit();
           if (s6 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f667(s4, s6);
+            s0 = peg$f775(s4, s6);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -70540,11 +80061,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 8);
-      if (s1.toLowerCase() === peg$c192) {
+      if (s1.toLowerCase() === peg$c225) {
         peg$currPos += (8);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e202); }
+        if (peg$silentFails === 0) { peg$fail(peg$e237); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -70568,7 +80089,7 @@ function peg$parse(input, options) {
           s4 = peg$parseStringLiteral();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f668(s4);
+            s0 = peg$f776(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -70591,7 +80112,7 @@ function peg$parse(input, options) {
   function peg$parseIntervalUnit() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 378;
+    const key = peg$currPos * 508 + 420;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -70604,11 +80125,11 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     s2 = peg$currPos;
     s3 = input.charAt(peg$currPos);
-    if (peg$r8.test(s3)) {
+    if (peg$r5.test(s3)) {
       peg$currPos++;
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e184); }
+      if (peg$silentFails === 0) { peg$fail(peg$e129); }
     }
     if (s3 !== peg$FAILED) {
       s4 = [];
@@ -70642,7 +80163,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = peg$currPos;
-      s2 = peg$f669(s1);
+      s2 = peg$f777(s1);
       if (s2) {
         s2 = undefined;
       } else {
@@ -70650,7 +80171,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f670(s1);
+        s0 = peg$f778(s1);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -70668,7 +80189,7 @@ function peg$parse(input, options) {
   function peg$parseDateAddName() {
     let s0, s1;
 
-    const key = peg$currPos * 466 + 379;
+    const key = peg$currPos * 508 + 421;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -70679,42 +80200,42 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c328) {
+    if (s1.toLowerCase() === peg$c358) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e363); }
+      if (peg$silentFails === 0) { peg$fail(peg$e395); }
     }
     if (s1 === peg$FAILED) {
       s1 = input.substr(peg$currPos, 7);
-      if (s1.toLowerCase() === peg$c329) {
+      if (s1.toLowerCase() === peg$c359) {
         peg$currPos += (7);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e364); }
+        if (peg$silentFails === 0) { peg$fail(peg$e396); }
       }
       if (s1 === peg$FAILED) {
         s1 = input.substr(peg$currPos, 13);
-        if (s1.toLowerCase() === peg$c330) {
+        if (s1.toLowerCase() === peg$c360) {
           peg$currPos += (13);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e365); }
+          if (peg$silentFails === 0) { peg$fail(peg$e397); }
         }
         if (s1 === peg$FAILED) {
           s1 = input.substr(peg$currPos, 12);
-          if (s1.toLowerCase() === peg$c331) {
+          if (s1.toLowerCase() === peg$c361) {
             peg$currPos += (12);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e366); }
+            if (peg$silentFails === 0) { peg$fail(peg$e398); }
           }
         }
       }
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f671();
+      s1 = peg$f779();
     }
     s0 = s1;
 
@@ -70726,7 +80247,7 @@ function peg$parse(input, options) {
   function peg$parseDateSubName() {
     let s0, s1;
 
-    const key = peg$currPos * 466 + 380;
+    const key = peg$currPos * 508 + 422;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -70737,42 +80258,42 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c332) {
+    if (s1.toLowerCase() === peg$c362) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e367); }
+      if (peg$silentFails === 0) { peg$fail(peg$e399); }
     }
     if (s1 === peg$FAILED) {
       s1 = input.substr(peg$currPos, 7);
-      if (s1.toLowerCase() === peg$c333) {
+      if (s1.toLowerCase() === peg$c363) {
         peg$currPos += (7);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e368); }
+        if (peg$silentFails === 0) { peg$fail(peg$e400); }
       }
       if (s1 === peg$FAILED) {
         s1 = input.substr(peg$currPos, 13);
-        if (s1.toLowerCase() === peg$c334) {
+        if (s1.toLowerCase() === peg$c364) {
           peg$currPos += (13);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e369); }
+          if (peg$silentFails === 0) { peg$fail(peg$e401); }
         }
         if (s1 === peg$FAILED) {
           s1 = input.substr(peg$currPos, 12);
-          if (s1.toLowerCase() === peg$c335) {
+          if (s1.toLowerCase() === peg$c365) {
             peg$currPos += (12);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e370); }
+            if (peg$silentFails === 0) { peg$fail(peg$e402); }
           }
         }
       }
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f672();
+      s1 = peg$f780();
     }
     s0 = s1;
 
@@ -70784,7 +80305,7 @@ function peg$parse(input, options) {
   function peg$parseDateAddSubArgs() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-    const key = peg$currPos * 466 + 381;
+    const key = peg$currPos * 508 + 423;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -70798,11 +80319,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s3 = peg$c15;
+        s3 = peg$c24;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -70810,18 +80331,18 @@ function peg$parse(input, options) {
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s7 = peg$c15;
+            s7 = peg$c24;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$parse_();
             s9 = peg$parseExpressionWithImplicitAlias();
             if (s9 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f673(s1, s5, s9);
+              s0 = peg$f781(s1, s5, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -70848,18 +80369,18 @@ function peg$parse(input, options) {
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s3 = peg$c15;
+          s3 = peg$c24;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
           s5 = peg$parseIntervalExpr();
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f674(s1, s5);
+            s0 = peg$f782(s1, s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -70878,18 +80399,18 @@ function peg$parse(input, options) {
         if (s1 !== peg$FAILED) {
           s2 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 44) {
-            s3 = peg$c15;
+            s3 = peg$c24;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
           }
           if (s3 !== peg$FAILED) {
             s4 = peg$parse_();
             s5 = peg$parseExpressionWithImplicitAlias();
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f675(s1, s5);
+              s0 = peg$f783(s1, s5);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -70913,7 +80434,7 @@ function peg$parse(input, options) {
   function peg$parseFunctionCall() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19;
 
-    const key = peg$currPos * 466 + 382;
+    const key = peg$currPos * 508 + 424;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -70927,11 +80448,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s3 = peg$c21;
+        s3 = peg$c25;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -70939,15 +80460,15 @@ function peg$parse(input, options) {
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 41) {
-            s7 = peg$c22;
+            s7 = peg$c26;
             peg$currPos++;
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e26); }
+            if (peg$silentFails === 0) { peg$fail(peg$e30); }
           }
           if (s7 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f676(s1, s5);
+            s0 = peg$f784(s1, s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -70970,11 +80491,11 @@ function peg$parse(input, options) {
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s3 = peg$c21;
+          s3 = peg$c25;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
@@ -70982,15 +80503,15 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s7 = peg$c22;
+              s7 = peg$c26;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f677(s1, s5);
+              s0 = peg$f785(s1, s5);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -71013,11 +80534,11 @@ function peg$parse(input, options) {
         if (s1 !== peg$FAILED) {
           s2 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 40) {
-            s3 = peg$c21;
+            s3 = peg$c25;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s3 !== peg$FAILED) {
             s4 = peg$parse_();
@@ -71025,11 +80546,11 @@ function peg$parse(input, options) {
             if (s5 !== peg$FAILED) {
               s6 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 44) {
-                s7 = peg$c15;
+                s7 = peg$c24;
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
               }
               if (s7 !== peg$FAILED) {
                 s8 = peg$parse_();
@@ -71037,11 +80558,11 @@ function peg$parse(input, options) {
                 if (s9 !== peg$FAILED) {
                   s10 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 44) {
-                    s11 = peg$c15;
+                    s11 = peg$c24;
                     peg$currPos++;
                   } else {
                     s11 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e28); }
                   }
                   if (s11 !== peg$FAILED) {
                     s12 = peg$parse_();
@@ -71049,15 +80570,15 @@ function peg$parse(input, options) {
                     if (s13 !== peg$FAILED) {
                       s14 = peg$parse_();
                       if (input.charCodeAt(peg$currPos) === 41) {
-                        s15 = peg$c22;
+                        s15 = peg$c26;
                         peg$currPos++;
                       } else {
                         s15 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e30); }
                       }
                       if (s15 !== peg$FAILED) {
                         peg$savedPos = s0;
-                        s0 = peg$f678(s5, s9, s13);
+                        s0 = peg$f786(s5, s9, s13);
                       } else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
@@ -71093,49 +80614,49 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 8);
-          if (s1.toLowerCase() === peg$c336) {
+          if (s1.toLowerCase() === peg$c366) {
             peg$currPos += (8);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e371); }
+            if (peg$silentFails === 0) { peg$fail(peg$e403); }
           }
           if (s1 === peg$FAILED) {
             s1 = input.substr(peg$currPos, 8);
-            if (s1.toLowerCase() === peg$c336) {
+            if (s1.toLowerCase() === peg$c366) {
               peg$currPos += (8);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e372); }
+              if (peg$silentFails === 0) { peg$fail(peg$e404); }
             }
             if (s1 === peg$FAILED) {
               s1 = input.substr(peg$currPos, 9);
-              if (s1.toLowerCase() === peg$c337) {
+              if (s1.toLowerCase() === peg$c367) {
                 peg$currPos += (9);
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e373); }
+                if (peg$silentFails === 0) { peg$fail(peg$e405); }
               }
             }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s3 = peg$c21;
+              s3 = peg$c25;
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s3 !== peg$FAILED) {
               s4 = peg$parse_();
               s5 = peg$currPos;
               s6 = peg$currPos;
               s7 = input.charAt(peg$currPos);
-              if (peg$r8.test(s7)) {
+              if (peg$r5.test(s7)) {
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e184); }
+                if (peg$silentFails === 0) { peg$fail(peg$e129); }
               }
               if (s7 !== peg$FAILED) {
                 s8 = [];
@@ -71170,11 +80691,11 @@ function peg$parse(input, options) {
               if (s5 !== peg$FAILED) {
                 s6 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 44) {
-                  s7 = peg$c15;
+                  s7 = peg$c24;
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e17); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e28); }
                 }
                 if (s7 !== peg$FAILED) {
                   s8 = peg$parse_();
@@ -71182,15 +80703,15 @@ function peg$parse(input, options) {
                   if (s9 !== peg$FAILED) {
                     s10 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 41) {
-                      s11 = peg$c22;
+                      s11 = peg$c26;
                       peg$currPos++;
                     } else {
                       s11 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e30); }
                     }
                     if (s11 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s0 = peg$f679(s5, s9);
+                      s0 = peg$f787(s5, s9);
                     } else {
                       peg$currPos = s0;
                       s0 = peg$FAILED;
@@ -71218,38 +80739,38 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = input.substr(peg$currPos, 8);
-            if (s1.toLowerCase() === peg$c336) {
+            if (s1.toLowerCase() === peg$c366) {
               peg$currPos += (8);
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e371); }
+              if (peg$silentFails === 0) { peg$fail(peg$e403); }
             }
             if (s1 === peg$FAILED) {
               s1 = input.substr(peg$currPos, 8);
-              if (s1.toLowerCase() === peg$c336) {
+              if (s1.toLowerCase() === peg$c366) {
                 peg$currPos += (8);
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e372); }
+                if (peg$silentFails === 0) { peg$fail(peg$e404); }
               }
               if (s1 === peg$FAILED) {
                 s1 = input.substr(peg$currPos, 9);
-                if (s1.toLowerCase() === peg$c337) {
+                if (s1.toLowerCase() === peg$c367) {
                   peg$currPos += (9);
                 } else {
                   s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e373); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e405); }
                 }
               }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 40) {
-                s3 = peg$c21;
+                s3 = peg$c25;
                 peg$currPos++;
               } else {
                 s3 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                if (peg$silentFails === 0) { peg$fail(peg$e29); }
               }
               if (s3 !== peg$FAILED) {
                 s4 = peg$parse_();
@@ -71257,15 +80778,15 @@ function peg$parse(input, options) {
                 if (s5 !== peg$FAILED) {
                   s6 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 41) {
-                    s7 = peg$c22;
+                    s7 = peg$c26;
                     peg$currPos++;
                   } else {
                     s7 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
                   }
                   if (s7 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f680(s5);
+                    s0 = peg$f788(s5);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -71285,38 +80806,38 @@ function peg$parse(input, options) {
             if (s0 === peg$FAILED) {
               s0 = peg$currPos;
               s1 = input.substr(peg$currPos, 9);
-              if (s1.toLowerCase() === peg$c338) {
+              if (s1.toLowerCase() === peg$c368) {
                 peg$currPos += (9);
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e374); }
+                if (peg$silentFails === 0) { peg$fail(peg$e406); }
               }
               if (s1 === peg$FAILED) {
                 s1 = input.substr(peg$currPos, 6);
-                if (s1.toLowerCase() === peg$c339) {
+                if (s1.toLowerCase() === peg$c369) {
                   peg$currPos += (6);
                 } else {
                   s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e375); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e407); }
                 }
                 if (s1 === peg$FAILED) {
                   s1 = input.substr(peg$currPos, 3);
-                  if (s1.toLowerCase() === peg$c340) {
+                  if (s1.toLowerCase() === peg$c370) {
                     peg$currPos += (3);
                   } else {
                     s1 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e376); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e408); }
                   }
                 }
               }
               if (s1 !== peg$FAILED) {
                 s2 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 40) {
-                  s3 = peg$c21;
+                  s3 = peg$c25;
                   peg$currPos++;
                 } else {
                   s3 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e29); }
                 }
                 if (s3 !== peg$FAILED) {
                   s4 = peg$parse_();
@@ -71324,11 +80845,11 @@ function peg$parse(input, options) {
                   if (s5 !== peg$FAILED) {
                     s6 = peg$parse_();
                     s7 = input.substr(peg$currPos, 4);
-                    if (s7.toLowerCase() === peg$c69) {
+                    if (s7.toLowerCase() === peg$c73) {
                       peg$currPos += (4);
                     } else {
                       s7 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e74); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e78); }
                     }
                     if (s7 !== peg$FAILED) {
                       s8 = peg$currPos;
@@ -71354,11 +80875,11 @@ function peg$parse(input, options) {
                           s11 = peg$currPos;
                           s12 = peg$parse_();
                           s13 = input.substr(peg$currPos, 3);
-                          if (s13.toLowerCase() === peg$c186) {
+                          if (s13.toLowerCase() === peg$c122) {
                             peg$currPos += (3);
                           } else {
                             s13 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e196); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e128); }
                           }
                           if (s13 !== peg$FAILED) {
                             s14 = peg$currPos;
@@ -71400,15 +80921,15 @@ function peg$parse(input, options) {
                           }
                           s12 = peg$parse_();
                           if (input.charCodeAt(peg$currPos) === 41) {
-                            s13 = peg$c22;
+                            s13 = peg$c26;
                             peg$currPos++;
                           } else {
                             s13 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e30); }
                           }
                           if (s13 !== peg$FAILED) {
                             peg$savedPos = s0;
-                            s0 = peg$f681(s5, s10, s11);
+                            s0 = peg$f789(s5, s10, s11);
                           } else {
                             peg$currPos = s0;
                             s0 = peg$FAILED;
@@ -71440,20 +80961,20 @@ function peg$parse(input, options) {
               if (s0 === peg$FAILED) {
                 s0 = peg$currPos;
                 s1 = input.substr(peg$currPos, 7);
-                if (s1.toLowerCase() === peg$c341) {
+                if (s1.toLowerCase() === peg$c371) {
                   peg$currPos += (7);
                 } else {
                   s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e377); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e409); }
                 }
                 if (s1 !== peg$FAILED) {
                   s2 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 40) {
-                    s3 = peg$c21;
+                    s3 = peg$c25;
                     peg$currPos++;
                   } else {
                     s3 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e29); }
                   }
                   if (s3 !== peg$FAILED) {
                     s4 = peg$parse_();
@@ -71461,11 +80982,11 @@ function peg$parse(input, options) {
                     if (s5 !== peg$FAILED) {
                       s6 = peg$parse_();
                       s7 = input.substr(peg$currPos, 4);
-                      if (s7.toLowerCase() === peg$c69) {
+                      if (s7.toLowerCase() === peg$c73) {
                         peg$currPos += (4);
                       } else {
                         s7 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e74); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e78); }
                       }
                       if (s7 !== peg$FAILED) {
                         s8 = peg$currPos;
@@ -71490,15 +81011,15 @@ function peg$parse(input, options) {
                           if (s10 !== peg$FAILED) {
                             s11 = peg$parse_();
                             if (input.charCodeAt(peg$currPos) === 41) {
-                              s12 = peg$c22;
+                              s12 = peg$c26;
                               peg$currPos++;
                             } else {
                               s12 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e30); }
                             }
                             if (s12 !== peg$FAILED) {
                               peg$savedPos = s0;
-                              s0 = peg$f682(s5, s10);
+                              s0 = peg$f790(s5, s10);
                             } else {
                               peg$currPos = s0;
                               s0 = peg$FAILED;
@@ -71530,20 +81051,20 @@ function peg$parse(input, options) {
                 if (s0 === peg$FAILED) {
                   s0 = peg$currPos;
                   s1 = input.substr(peg$currPos, 4);
-                  if (s1.toLowerCase() === peg$c342) {
+                  if (s1.toLowerCase() === peg$c372) {
                     peg$currPos += (4);
                   } else {
                     s1 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e378); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e410); }
                   }
                   if (s1 !== peg$FAILED) {
                     s2 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 40) {
-                      s3 = peg$c21;
+                      s3 = peg$c25;
                       peg$currPos++;
                     } else {
                       s3 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e29); }
                     }
                     if (s3 !== peg$FAILED) {
                       s4 = peg$parse_();
@@ -71554,11 +81075,11 @@ function peg$parse(input, options) {
                         if (s7 !== peg$FAILED) {
                           s8 = peg$parse_();
                           s9 = input.substr(peg$currPos, 4);
-                          if (s9.toLowerCase() === peg$c69) {
+                          if (s9.toLowerCase() === peg$c73) {
                             peg$currPos += (4);
                           } else {
                             s9 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e74); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e78); }
                           }
                           if (s9 !== peg$FAILED) {
                             s10 = peg$currPos;
@@ -71583,15 +81104,15 @@ function peg$parse(input, options) {
                               if (s12 !== peg$FAILED) {
                                 s13 = peg$parse_();
                                 if (input.charCodeAt(peg$currPos) === 41) {
-                                  s14 = peg$c22;
+                                  s14 = peg$c26;
                                   peg$currPos++;
                                 } else {
                                   s14 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                                 }
                                 if (s14 !== peg$FAILED) {
                                   peg$savedPos = s0;
-                                  s0 = peg$f683(s5, s7, s12);
+                                  s0 = peg$f791(s5, s7, s12);
                                 } else {
                                   peg$currPos = s0;
                                   s0 = peg$FAILED;
@@ -71627,20 +81148,20 @@ function peg$parse(input, options) {
                   if (s0 === peg$FAILED) {
                     s0 = peg$currPos;
                     s1 = input.substr(peg$currPos, 8);
-                    if (s1.toLowerCase() === peg$c343) {
+                    if (s1.toLowerCase() === peg$c373) {
                       peg$currPos += (8);
                     } else {
                       s1 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e379); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e411); }
                     }
                     if (s1 !== peg$FAILED) {
                       s2 = peg$parse_();
                       if (input.charCodeAt(peg$currPos) === 40) {
-                        s3 = peg$c21;
+                        s3 = peg$c25;
                         peg$currPos++;
                       } else {
                         s3 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e29); }
                       }
                       if (s3 !== peg$FAILED) {
                         s4 = peg$parse_();
@@ -71648,11 +81169,11 @@ function peg$parse(input, options) {
                         if (s5 !== peg$FAILED) {
                           s6 = peg$parse_();
                           s7 = input.substr(peg$currPos, 2);
-                          if (s7.toLowerCase() === peg$c89) {
+                          if (s7.toLowerCase() === peg$c93) {
                             peg$currPos += (2);
                           } else {
                             s7 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e94); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e98); }
                           }
                           if (s7 !== peg$FAILED) {
                             s8 = peg$currPos;
@@ -71677,15 +81198,15 @@ function peg$parse(input, options) {
                               if (s10 !== peg$FAILED) {
                                 s11 = peg$parse_();
                                 if (input.charCodeAt(peg$currPos) === 41) {
-                                  s12 = peg$c22;
+                                  s12 = peg$c26;
                                   peg$currPos++;
                                 } else {
                                   s12 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                                 }
                                 if (s12 !== peg$FAILED) {
                                   peg$savedPos = s0;
-                                  s0 = peg$f684(s5, s10);
+                                  s0 = peg$f792(s5, s10);
                                 } else {
                                   peg$currPos = s0;
                                   s0 = peg$FAILED;
@@ -71717,11 +81238,11 @@ function peg$parse(input, options) {
                     if (s0 === peg$FAILED) {
                       s0 = peg$currPos;
                       s1 = input.substr(peg$currPos, 4);
-                      if (s1.toLowerCase() === peg$c344) {
+                      if (s1.toLowerCase() === peg$c374) {
                         peg$currPos += (4);
                       } else {
                         s1 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e380); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e412); }
                       }
                       if (s1 !== peg$FAILED) {
                         s2 = peg$currPos;
@@ -71745,7 +81266,7 @@ function peg$parse(input, options) {
                           s4 = peg$parseStringLiteral();
                           if (s4 !== peg$FAILED) {
                             peg$savedPos = s0;
-                            s0 = peg$f685(s4);
+                            s0 = peg$f793(s4);
                           } else {
                             peg$currPos = s0;
                             s0 = peg$FAILED;
@@ -71761,11 +81282,11 @@ function peg$parse(input, options) {
                       if (s0 === peg$FAILED) {
                         s0 = peg$currPos;
                         s1 = input.substr(peg$currPos, 9);
-                        if (s1.toLowerCase() === peg$c345) {
+                        if (s1.toLowerCase() === peg$c375) {
                           peg$currPos += (9);
                         } else {
                           s1 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e381); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e413); }
                         }
                         if (s1 !== peg$FAILED) {
                           s2 = peg$currPos;
@@ -71789,7 +81310,7 @@ function peg$parse(input, options) {
                             s4 = peg$parseStringLiteral();
                             if (s4 !== peg$FAILED) {
                               peg$savedPos = s0;
-                              s0 = peg$f686(s4);
+                              s0 = peg$f794(s4);
                             } else {
                               peg$currPos = s0;
                               s0 = peg$FAILED;
@@ -71805,11 +81326,11 @@ function peg$parse(input, options) {
                         if (s0 === peg$FAILED) {
                           s0 = peg$currPos;
                           s1 = input.substr(peg$currPos, 4);
-                          if (s1.toLowerCase() === peg$c211) {
+                          if (s1.toLowerCase() === peg$c244) {
                             peg$currPos += (4);
                           } else {
                             s1 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e221); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e256); }
                           }
                           if (s1 !== peg$FAILED) {
                             s2 = peg$currPos;
@@ -71833,7 +81354,7 @@ function peg$parse(input, options) {
                               s4 = peg$parseStringLiteral();
                               if (s4 !== peg$FAILED) {
                                 peg$savedPos = s0;
-                                s0 = peg$f687(s4);
+                                s0 = peg$f795(s4);
                               } else {
                                 peg$currPos = s0;
                                 s0 = peg$FAILED;
@@ -71849,20 +81370,20 @@ function peg$parse(input, options) {
                           if (s0 === peg$FAILED) {
                             s0 = peg$currPos;
                             s1 = input.substr(peg$currPos, 4);
-                            if (s1.toLowerCase() === peg$c346) {
+                            if (s1.toLowerCase() === peg$c376) {
                               peg$currPos += (4);
                             } else {
                               s1 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e382); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e414); }
                             }
                             if (s1 !== peg$FAILED) {
                               s2 = peg$parse_();
                               if (input.charCodeAt(peg$currPos) === 40) {
-                                s3 = peg$c21;
+                                s3 = peg$c25;
                                 peg$currPos++;
                               } else {
                                 s3 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                                if (peg$silentFails === 0) { peg$fail(peg$e29); }
                               }
                               if (s3 !== peg$FAILED) {
                                 s4 = peg$parse_();
@@ -71906,7 +81427,7 @@ function peg$parse(input, options) {
                                     }
                                     if (s10 !== peg$FAILED) {
                                       peg$savedPos = s6;
-                                      s6 = peg$f688(s5, s9);
+                                      s6 = peg$f796(s5, s9);
                                     } else {
                                       peg$currPos = s6;
                                       s6 = peg$FAILED;
@@ -71926,15 +81447,15 @@ function peg$parse(input, options) {
                                     if (s10 !== peg$FAILED) {
                                       s11 = peg$parse_();
                                       if (input.charCodeAt(peg$currPos) === 41) {
-                                        s12 = peg$c22;
+                                        s12 = peg$c26;
                                         peg$currPos++;
                                       } else {
                                         s12 = peg$FAILED;
-                                        if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                                        if (peg$silentFails === 0) { peg$fail(peg$e30); }
                                       }
                                       if (s12 !== peg$FAILED) {
                                         peg$savedPos = s0;
-                                        s0 = peg$f689(s5, s6, s10);
+                                        s0 = peg$f797(s5, s6, s10);
                                       } else {
                                         peg$currPos = s0;
                                         s0 = peg$FAILED;
@@ -71965,11 +81486,11 @@ function peg$parse(input, options) {
                               if (s1 !== peg$FAILED) {
                                 s2 = peg$parse_();
                                 if (input.charCodeAt(peg$currPos) === 40) {
-                                  s3 = peg$c21;
+                                  s3 = peg$c25;
                                   peg$currPos++;
                                 } else {
                                   s3 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e29); }
                                 }
                                 if (s3 !== peg$FAILED) {
                                   s4 = peg$parse_();
@@ -71988,7 +81509,7 @@ function peg$parse(input, options) {
                                       peg$currPos++;
                                     } else {
                                       s10 = peg$FAILED;
-                                      if (peg$silentFails === 0) { peg$fail(peg$e50); }
+                                      if (peg$silentFails === 0) { peg$fail(peg$e54); }
                                     }
                                     if (s10 !== peg$FAILED) {
                                       s9 = [s9, s10];
@@ -72045,21 +81566,21 @@ function peg$parse(input, options) {
                                   }
                                   s8 = peg$parse_();
                                   if (input.charCodeAt(peg$currPos) === 41) {
-                                    s9 = peg$c22;
+                                    s9 = peg$c26;
                                     peg$currPos++;
                                   } else {
                                     s9 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
                                   }
                                   if (s9 !== peg$FAILED) {
                                     s10 = peg$currPos;
                                     s11 = peg$parse_();
                                     if (input.charCodeAt(peg$currPos) === 40) {
-                                      s12 = peg$c21;
+                                      s12 = peg$c25;
                                       peg$currPos++;
                                     } else {
                                       s12 = peg$FAILED;
-                                      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                                      if (peg$silentFails === 0) { peg$fail(peg$e29); }
                                     }
                                     if (s12 !== peg$FAILED) {
                                       s13 = peg$parse_();
@@ -72078,7 +81599,7 @@ function peg$parse(input, options) {
                                           peg$currPos++;
                                         } else {
                                           s19 = peg$FAILED;
-                                          if (peg$silentFails === 0) { peg$fail(peg$e50); }
+                                          if (peg$silentFails === 0) { peg$fail(peg$e54); }
                                         }
                                         if (s19 !== peg$FAILED) {
                                           s18 = [s18, s19];
@@ -72115,11 +81636,11 @@ function peg$parse(input, options) {
                                       }
                                       s16 = peg$parse_();
                                       if (input.charCodeAt(peg$currPos) === 41) {
-                                        s17 = peg$c22;
+                                        s17 = peg$c26;
                                         peg$currPos++;
                                       } else {
                                         s17 = peg$FAILED;
-                                        if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                                        if (peg$silentFails === 0) { peg$fail(peg$e30); }
                                       }
                                       if (s17 !== peg$FAILED) {
                                         s11 = [s11, s12, s13, s14, s15, s16, s17];
@@ -72140,7 +81661,7 @@ function peg$parse(input, options) {
                                       s11 = null;
                                     }
                                     peg$savedPos = s0;
-                                    s0 = peg$f690(s1, s4, s5, s6, s7, s10, s11);
+                                    s0 = peg$f798(s1, s4, s5, s6, s7, s10, s11);
                                   } else {
                                     peg$currPos = s0;
                                     s0 = peg$FAILED;
@@ -72175,7 +81696,7 @@ function peg$parse(input, options) {
   function peg$parseExtractUnit() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 383;
+    const key = peg$currPos * 508 + 425;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -72188,11 +81709,11 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     s2 = peg$currPos;
     s3 = input.charAt(peg$currPos);
-    if (peg$r8.test(s3)) {
+    if (peg$r5.test(s3)) {
       peg$currPos++;
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e184); }
+      if (peg$silentFails === 0) { peg$fail(peg$e129); }
     }
     if (s3 !== peg$FAILED) {
       s4 = [];
@@ -72226,7 +81747,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f691(s1);
+      s1 = peg$f799(s1);
     }
     s0 = s1;
 
@@ -72238,7 +81759,7 @@ function peg$parse(input, options) {
   function peg$parseTrimDirection() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 384;
+    const key = peg$currPos * 508 + 426;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -72249,11 +81770,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c347) {
+    if (s1.toLowerCase() === peg$c377) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e383); }
+      if (peg$silentFails === 0) { peg$fail(peg$e415); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -72274,7 +81795,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f692();
+        s0 = peg$f800();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -72286,11 +81807,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 8);
-      if (s1.toLowerCase() === peg$c348) {
+      if (s1.toLowerCase() === peg$c378) {
         peg$currPos += (8);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e384); }
+        if (peg$silentFails === 0) { peg$fail(peg$e416); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -72311,7 +81832,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f693();
+          s0 = peg$f801();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -72323,11 +81844,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 4);
-        if (s1.toLowerCase() === peg$c349) {
+        if (s1.toLowerCase() === peg$c379) {
           peg$currPos += (4);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e385); }
+          if (peg$silentFails === 0) { peg$fail(peg$e417); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -72348,7 +81869,7 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f694();
+            s0 = peg$f802();
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -72368,7 +81889,7 @@ function peg$parse(input, options) {
   function peg$parseFilterClause() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 385;
+    const key = peg$currPos * 508 + 427;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -72380,29 +81901,29 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     s2 = input.substr(peg$currPos, 6);
-    if (s2.toLowerCase() === peg$c350) {
+    if (s2.toLowerCase() === peg$c380) {
       peg$currPos += (6);
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e386); }
+      if (peg$silentFails === 0) { peg$fail(peg$e418); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 40) {
-        s4 = peg$c21;
+        s4 = peg$c25;
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        if (peg$silentFails === 0) { peg$fail(peg$e29); }
       }
       if (s4 !== peg$FAILED) {
         s5 = peg$parse_();
         s6 = input.substr(peg$currPos, 5);
-        if (s6.toLowerCase() === peg$c61) {
+        if (s6.toLowerCase() === peg$c65) {
           peg$currPos += (5);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e66); }
+          if (peg$silentFails === 0) { peg$fail(peg$e70); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$currPos;
@@ -72427,15 +81948,15 @@ function peg$parse(input, options) {
             if (s9 !== peg$FAILED) {
               s10 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s11 = peg$c22;
+                s11 = peg$c26;
                 peg$currPos++;
               } else {
                 s11 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s11 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f695(s9);
+                s0 = peg$f803(s9);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -72469,7 +81990,7 @@ function peg$parse(input, options) {
   function peg$parseFunctionName() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 386;
+    const key = peg$currPos * 508 + 428;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -72480,11 +82001,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.charAt(peg$currPos);
-    if (peg$r8.test(s1)) {
+    if (peg$r5.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e184); }
+      if (peg$silentFails === 0) { peg$fail(peg$e129); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
@@ -72506,7 +82027,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f696(s1, s2);
+      s0 = peg$f804(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -72540,7 +82061,7 @@ function peg$parse(input, options) {
           }
         }
         peg$savedPos = s0;
-        s0 = peg$f697(s1, s2);
+        s0 = peg$f805(s1, s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -72548,11 +82069,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 34) {
-          s1 = peg$c255;
+          s1 = peg$c285;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e274); }
+          if (peg$silentFails === 0) { peg$fail(peg$e306); }
         }
         if (s1 !== peg$FAILED) {
           s2 = [];
@@ -72562,15 +82083,15 @@ function peg$parse(input, options) {
             s3 = peg$parseDoubleQuotedChar();
           }
           if (input.charCodeAt(peg$currPos) === 34) {
-            s3 = peg$c255;
+            s3 = peg$c285;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e274); }
+            if (peg$silentFails === 0) { peg$fail(peg$e306); }
           }
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f698(s2);
+            s0 = peg$f806(s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -72582,11 +82103,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 96) {
-            s1 = peg$c219;
+            s1 = peg$c124;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e231); }
+            if (peg$silentFails === 0) { peg$fail(peg$e133); }
           }
           if (s1 !== peg$FAILED) {
             s2 = [];
@@ -72596,15 +82117,15 @@ function peg$parse(input, options) {
               s3 = peg$parseBacktickChar();
             }
             if (input.charCodeAt(peg$currPos) === 96) {
-              s3 = peg$c219;
+              s3 = peg$c124;
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e231); }
+              if (peg$silentFails === 0) { peg$fail(peg$e133); }
             }
             if (s3 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f699(s2);
+              s0 = peg$f807(s2);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -72625,7 +82146,7 @@ function peg$parse(input, options) {
   function peg$parseFunctionCallArgGuarded() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 387;
+    const key = peg$currPos * 508 + 429;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -72642,11 +82163,11 @@ function peg$parse(input, options) {
     if (s3 !== peg$FAILED) {
       s4 = peg$parse_();
       s5 = input.charAt(peg$currPos);
-      if (peg$r8.test(s5)) {
+      if (peg$r5.test(s5)) {
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e184); }
+        if (peg$silentFails === 0) { peg$fail(peg$e129); }
       }
       if (s5 !== peg$FAILED) {
         s6 = [];
@@ -72669,11 +82190,11 @@ function peg$parse(input, options) {
         }
         s7 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 61) {
-          s8 = peg$c62;
+          s8 = peg$c66;
           peg$currPos++;
         } else {
           s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e67); }
+          if (peg$silentFails === 0) { peg$fail(peg$e71); }
         }
         if (s8 !== peg$FAILED) {
           s3 = [s3, s4, s5, s6, s7, s8];
@@ -72701,7 +82222,7 @@ function peg$parse(input, options) {
       s2 = peg$parseFunctionCallArg();
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f700(s2);
+        s0 = peg$f808(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -72719,7 +82240,7 @@ function peg$parse(input, options) {
   function peg$parseFunctionCallArgList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 388;
+    const key = peg$currPos * 508 + 430;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -72735,11 +82256,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -72760,11 +82281,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -72784,11 +82305,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s4 = [s4, s5];
@@ -72801,7 +82322,7 @@ function peg$parse(input, options) {
         s3 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f701(s1, s2);
+      s0 = peg$f809(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -72815,7 +82336,7 @@ function peg$parse(input, options) {
   function peg$parseFunctionCallArg() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 389;
+    const key = peg$currPos * 508 + 431;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -72828,19 +82349,19 @@ function peg$parse(input, options) {
     s1 = peg$parseMultiLambdaParams();
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
-      if (input.substr(peg$currPos, 2) === peg$c241) {
-        s3 = peg$c241;
+      if (input.substr(peg$currPos, 2) === peg$c272) {
+        s3 = peg$c272;
         peg$currPos += 2;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e255); }
+        if (peg$silentFails === 0) { peg$fail(peg$e288); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$parseExpression();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f702(s1, s5);
+          s0 = peg$f810(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -72872,7 +82393,7 @@ function peg$parse(input, options) {
         s2 = peg$parseUnionQuery();
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f703(s2);
+          s0 = peg$f811(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -72896,7 +82417,7 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e50); }
+              if (peg$silentFails === 0) { peg$fail(peg$e54); }
             }
             if (s5 !== peg$FAILED) {
               s4 = [s4, s5];
@@ -72914,7 +82435,7 @@ function peg$parse(input, options) {
             }
             if (s2 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f704(s1);
+              s0 = peg$f812(s1);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -72935,7 +82456,7 @@ function peg$parse(input, options) {
   function peg$parseMultiLambdaParams() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 390;
+    const key = peg$currPos * 508 + 432;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -72949,18 +82470,18 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s3 = peg$c15;
+        s3 = peg$c24;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$parseMultiLambdaParamsTail();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f705(s1, s5);
+          s0 = peg$f813(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -72982,7 +82503,7 @@ function peg$parse(input, options) {
   function peg$parseMultiLambdaParamsTail() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 391;
+    const key = peg$currPos * 508 + 433;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -72996,18 +82517,18 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s3 = peg$c15;
+        s3 = peg$c24;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         s5 = peg$parseMultiLambdaParamsTail();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f706(s1, s5);
+          s0 = peg$f814(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -73028,12 +82549,12 @@ function peg$parse(input, options) {
         peg$silentFails++;
         s3 = peg$currPos;
         s4 = peg$parse_();
-        if (input.substr(peg$currPos, 2) === peg$c241) {
-          s5 = peg$c241;
+        if (input.substr(peg$currPos, 2) === peg$c272) {
+          s5 = peg$c272;
           peg$currPos += 2;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e255); }
+          if (peg$silentFails === 0) { peg$fail(peg$e288); }
         }
         if (s5 !== peg$FAILED) {
           s4 = [s4, s5];
@@ -73051,7 +82572,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f707(s1);
+          s0 = peg$f815(s1);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -73070,7 +82591,7 @@ function peg$parse(input, options) {
   function peg$parseColumnRef() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 392;
+    const key = peg$currPos * 508 + 434;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -73086,18 +82607,18 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 46) {
-        s5 = peg$c35;
+        s5 = peg$c39;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
         s7 = peg$parseColumnRefCont();
         if (s7 !== peg$FAILED) {
           peg$savedPos = s3;
-          s3 = peg$f708(s1, s7);
+          s3 = peg$f816(s1, s7);
         } else {
           peg$currPos = s3;
           s3 = peg$FAILED;
@@ -73112,18 +82633,18 @@ function peg$parse(input, options) {
           s3 = peg$currPos;
           s4 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 46) {
-            s5 = peg$c35;
+            s5 = peg$c39;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e39); }
+            if (peg$silentFails === 0) { peg$fail(peg$e43); }
           }
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             s7 = peg$parseColumnRefCont();
             if (s7 !== peg$FAILED) {
               peg$savedPos = s3;
-              s3 = peg$f708(s1, s7);
+              s3 = peg$f816(s1, s7);
             } else {
               peg$currPos = s3;
               s3 = peg$FAILED;
@@ -73139,11 +82660,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s4 = peg$c21;
+          s4 = peg$c25;
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$parse_();
@@ -73153,15 +82674,15 @@ function peg$parse(input, options) {
           }
           s7 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 41) {
-            s8 = peg$c22;
+            s8 = peg$c26;
             peg$currPos++;
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e26); }
+            if (peg$silentFails === 0) { peg$fail(peg$e30); }
           }
           if (s8 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f709(s1, s2, s6);
+            s0 = peg$f817(s1, s2, s6);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -73186,18 +82707,18 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 46) {
-          s5 = peg$c35;
+          s5 = peg$c39;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e39); }
+          if (peg$silentFails === 0) { peg$fail(peg$e43); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           s7 = peg$parseColumnRefCont();
           if (s7 !== peg$FAILED) {
             peg$savedPos = s3;
-            s3 = peg$f710(s1, s7);
+            s3 = peg$f818(s1, s7);
           } else {
             peg$currPos = s3;
             s3 = peg$FAILED;
@@ -73212,18 +82733,18 @@ function peg$parse(input, options) {
             s3 = peg$currPos;
             s4 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 46) {
-              s5 = peg$c35;
+              s5 = peg$c39;
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e39); }
+              if (peg$silentFails === 0) { peg$fail(peg$e43); }
             }
             if (s5 !== peg$FAILED) {
               s6 = peg$parse_();
               s7 = peg$parseColumnRefCont();
               if (s7 !== peg$FAILED) {
                 peg$savedPos = s3;
-                s3 = peg$f710(s1, s7);
+                s3 = peg$f818(s1, s7);
               } else {
                 peg$currPos = s3;
                 s3 = peg$FAILED;
@@ -73238,7 +82759,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f711(s1, s2);
+          s0 = peg$f819(s1, s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -73252,7 +82773,7 @@ function peg$parse(input, options) {
         s1 = peg$parseIdentifier();
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f712(s1);
+          s1 = peg$f820(s1);
         }
         s0 = s1;
         if (s0 === peg$FAILED) {
@@ -73269,21 +82790,21 @@ function peg$parse(input, options) {
           if (s3 !== peg$FAILED) {
             s4 = [];
             s5 = input.charAt(peg$currPos);
-            if (peg$r34.test(s5)) {
+            if (peg$r7.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e387); }
+              if (peg$silentFails === 0) { peg$fail(peg$e132); }
             }
             if (s5 !== peg$FAILED) {
               while (s5 !== peg$FAILED) {
                 s4.push(s5);
                 s5 = input.charAt(peg$currPos);
-                if (peg$r34.test(s5)) {
+                if (peg$r7.test(s5)) {
                   peg$currPos++;
                 } else {
                   s5 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e387); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e132); }
                 }
               }
             } else {
@@ -73307,7 +82828,7 @@ function peg$parse(input, options) {
           }
           if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
-            s1 = peg$f713(s1);
+            s1 = peg$f821(s1);
           }
           s0 = s1;
         }
@@ -73322,7 +82843,7 @@ function peg$parse(input, options) {
   function peg$parseColumnRefFirst() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 393;
+    const key = peg$currPos * 508 + 435;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -73347,21 +82868,21 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = [];
           s4 = input.charAt(peg$currPos);
-          if (peg$r34.test(s4)) {
+          if (peg$r7.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e387); }
+            if (peg$silentFails === 0) { peg$fail(peg$e132); }
           }
           if (s4 !== peg$FAILED) {
             while (s4 !== peg$FAILED) {
               s3.push(s4);
               s4 = input.charAt(peg$currPos);
-              if (peg$r34.test(s4)) {
+              if (peg$r7.test(s4)) {
                 peg$currPos++;
               } else {
                 s4 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e387); }
+                if (peg$silentFails === 0) { peg$fail(peg$e132); }
               }
             }
           } else {
@@ -73397,7 +82918,7 @@ function peg$parse(input, options) {
   function peg$parseColumnRefCont() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 394;
+    const key = peg$currPos * 508 + 436;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -73410,11 +82931,11 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     peg$silentFails++;
     s2 = input.charAt(peg$currPos);
-    if (peg$r35.test(s2)) {
+    if (peg$r36.test(s2)) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e388); }
+      if (peg$silentFails === 0) { peg$fail(peg$e419); }
     }
     peg$silentFails--;
     if (s2 === peg$FAILED) {
@@ -73425,27 +82946,27 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       if (input.charCodeAt(peg$currPos) === 94) {
-        s2 = peg$c351;
+        s2 = peg$c381;
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e389); }
+        if (peg$silentFails === 0) { peg$fail(peg$e420); }
       }
       if (s2 !== peg$FAILED) {
         s3 = peg$parseAliasName();
         if (s3 !== peg$FAILED) {
-          if (input.substr(peg$currPos, 2) === peg$c352) {
-            s4 = peg$c352;
+          if (input.substr(peg$currPos, 2) === peg$c382) {
+            s4 = peg$c382;
             peg$currPos += 2;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e390); }
+            if (peg$silentFails === 0) { peg$fail(peg$e421); }
           }
           if (s4 === peg$FAILED) {
             s4 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f714(s3, s4);
+          s0 = peg$f822(s3, s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -73463,11 +82984,11 @@ function peg$parse(input, options) {
       s1 = peg$currPos;
       peg$silentFails++;
       s2 = input.charAt(peg$currPos);
-      if (peg$r35.test(s2)) {
+      if (peg$r36.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e388); }
+        if (peg$silentFails === 0) { peg$fail(peg$e419); }
       }
       peg$silentFails--;
       if (s2 === peg$FAILED) {
@@ -73479,18 +83000,18 @@ function peg$parse(input, options) {
       if (s1 !== peg$FAILED) {
         s2 = peg$parseAliasName();
         if (s2 !== peg$FAILED) {
-          if (input.substr(peg$currPos, 2) === peg$c352) {
-            s3 = peg$c352;
+          if (input.substr(peg$currPos, 2) === peg$c382) {
+            s3 = peg$c382;
             peg$currPos += 2;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e390); }
+            if (peg$silentFails === 0) { peg$fail(peg$e421); }
           }
           if (s3 === peg$FAILED) {
             s3 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f715(s2, s3);
+          s0 = peg$f823(s2, s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -73509,7 +83030,7 @@ function peg$parse(input, options) {
   function peg$parseQualifiedAsterisk() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 395;
+    const key = peg$currPos * 508 + 437;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -73525,22 +83046,22 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 46) {
-        s5 = peg$c35;
+        s5 = peg$c39;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
         s7 = peg$currPos;
         peg$silentFails++;
         s8 = input.charAt(peg$currPos);
-        if (peg$r36.test(s8)) {
+        if (peg$r37.test(s8)) {
           peg$currPos++;
         } else {
           s8 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e391); }
+          if (peg$silentFails === 0) { peg$fail(peg$e422); }
         }
         peg$silentFails--;
         if (s8 === peg$FAILED) {
@@ -73553,7 +83074,7 @@ function peg$parse(input, options) {
           s8 = peg$parseIdentifier();
           if (s8 !== peg$FAILED) {
             peg$savedPos = s3;
-            s3 = peg$f716(s1, s8);
+            s3 = peg$f824(s1, s8);
           } else {
             peg$currPos = s3;
             s3 = peg$FAILED;
@@ -73571,22 +83092,22 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 46) {
-          s5 = peg$c35;
+          s5 = peg$c39;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e39); }
+          if (peg$silentFails === 0) { peg$fail(peg$e43); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           s7 = peg$currPos;
           peg$silentFails++;
           s8 = input.charAt(peg$currPos);
-          if (peg$r36.test(s8)) {
+          if (peg$r37.test(s8)) {
             peg$currPos++;
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e391); }
+            if (peg$silentFails === 0) { peg$fail(peg$e422); }
           }
           peg$silentFails--;
           if (s8 === peg$FAILED) {
@@ -73599,7 +83120,7 @@ function peg$parse(input, options) {
             s8 = peg$parseIdentifier();
             if (s8 !== peg$FAILED) {
               peg$savedPos = s3;
-              s3 = peg$f716(s1, s8);
+              s3 = peg$f824(s1, s8);
             } else {
               peg$currPos = s3;
               s3 = peg$FAILED;
@@ -73615,20 +83136,20 @@ function peg$parse(input, options) {
       }
       s3 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 46) {
-        s4 = peg$c35;
+        s4 = peg$c39;
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s4 !== peg$FAILED) {
         s5 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 42) {
-          s6 = peg$c185;
+          s6 = peg$c123;
           peg$currPos++;
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e195); }
+          if (peg$silentFails === 0) { peg$fail(peg$e130); }
         }
         if (s6 !== peg$FAILED) {
           s7 = [];
@@ -73656,7 +83177,7 @@ function peg$parse(input, options) {
             }
           }
           peg$savedPos = s0;
-          s0 = peg$f717(s1, s2, s7);
+          s0 = peg$f825(s1, s2, s7);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -73678,7 +83199,7 @@ function peg$parse(input, options) {
   function peg$parseAsterisk() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 396;
+    const key = peg$currPos * 508 + 438;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -73689,11 +83210,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 42) {
-      s1 = peg$c185;
+      s1 = peg$c123;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e195); }
+      if (peg$silentFails === 0) { peg$fail(peg$e130); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
@@ -73721,7 +83242,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f718(s2);
+      s0 = peg$f826(s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -73735,7 +83256,7 @@ function peg$parse(input, options) {
   function peg$parseColumnTransformer() {
     let s0;
 
-    const key = peg$currPos * 466 + 397;
+    const key = peg$currPos * 508 + 439;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -73760,7 +83281,7 @@ function peg$parse(input, options) {
   function peg$parseColumnTransformerExcept() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 398;
+    const key = peg$currPos * 508 + 440;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -73797,11 +83318,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c353) {
+        if (s4.toLowerCase() === peg$c383) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e392); }
+          if (peg$silentFails === 0) { peg$fail(peg$e423); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -73823,11 +83344,11 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s7 = peg$c21;
+              s7 = peg$c25;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
@@ -73835,15 +83356,15 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 41) {
-                  s11 = peg$c22;
+                  s11 = peg$c26;
                   peg$currPos++;
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
                 if (s11 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f719(s9);
+                  s0 = peg$f827(s9);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -73901,11 +83422,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 6);
-          if (s4.toLowerCase() === peg$c353) {
+          if (s4.toLowerCase() === peg$c383) {
             peg$currPos += (6);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e392); }
+            if (peg$silentFails === 0) { peg$fail(peg$e423); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -73929,7 +83450,7 @@ function peg$parse(input, options) {
               s7 = peg$parseIdentifier();
               if (s7 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f720(s7);
+                s0 = peg$f828(s7);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -73979,11 +83500,11 @@ function peg$parse(input, options) {
           if (s2 !== peg$FAILED) {
             s3 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s4 = peg$c21;
+              s4 = peg$c25;
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s4 !== peg$FAILED) {
               s5 = peg$parse_();
@@ -73991,15 +83512,15 @@ function peg$parse(input, options) {
               if (s6 !== peg$FAILED) {
                 s7 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 41) {
-                  s8 = peg$c22;
+                  s8 = peg$c26;
                   peg$currPos++;
                 } else {
                   s8 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
                 if (s8 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f721(s6);
+                  s0 = peg$f829(s6);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -74049,11 +83570,11 @@ function peg$parse(input, options) {
             if (s2 !== peg$FAILED) {
               s3 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 40) {
-                s4 = peg$c21;
+                s4 = peg$c25;
                 peg$currPos++;
               } else {
                 s4 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e25); }
+                if (peg$silentFails === 0) { peg$fail(peg$e29); }
               }
               if (s4 !== peg$FAILED) {
                 s5 = peg$parse_();
@@ -74061,15 +83582,15 @@ function peg$parse(input, options) {
                 if (s6 !== peg$FAILED) {
                   s7 = peg$parse_();
                   if (input.charCodeAt(peg$currPos) === 41) {
-                    s8 = peg$c22;
+                    s8 = peg$c26;
                     peg$currPos++;
                   } else {
                     s8 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
                   }
                   if (s8 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f722(s6);
+                    s0 = peg$f830(s6);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -74121,7 +83642,7 @@ function peg$parse(input, options) {
                 s4 = peg$parseStringLiteral();
                 if (s4 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f723(s4);
+                  s0 = peg$f831(s4);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -74165,7 +83686,7 @@ function peg$parse(input, options) {
                   s4 = peg$parseIdentifier();
                   if (s4 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f724(s4);
+                    s0 = peg$f832(s4);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -74192,7 +83713,7 @@ function peg$parse(input, options) {
   function peg$parseColumnTransformerExceptList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 399;
+    const key = peg$currPos * 508 + 441;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -74208,11 +83729,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -74233,11 +83754,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -74255,7 +83776,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f725(s1, s2);
+      s0 = peg$f833(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -74269,7 +83790,7 @@ function peg$parse(input, options) {
   function peg$parseColumnTransformerApply() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 400;
+    const key = peg$currPos * 508 + 442;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -74280,11 +83801,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c83) {
+    if (s1.toLowerCase() === peg$c87) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e88); }
+      if (peg$silentFails === 0) { peg$fail(peg$e92); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -74306,11 +83827,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s4 = peg$c21;
+          s4 = peg$c25;
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$parse_();
@@ -74318,15 +83839,15 @@ function peg$parse(input, options) {
           if (s6 !== peg$FAILED) {
             s7 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s8 = peg$c22;
+              s8 = peg$c26;
               peg$currPos++;
             } else {
               s8 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s8 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f726(s6);
+              s0 = peg$f834(s6);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -74350,11 +83871,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 5);
-      if (s1.toLowerCase() === peg$c83) {
+      if (s1.toLowerCase() === peg$c87) {
         peg$currPos += (5);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e88); }
+        if (peg$silentFails === 0) { peg$fail(peg$e92); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -74378,7 +83899,7 @@ function peg$parse(input, options) {
           s4 = peg$parseLambdaExprNoParens();
           if (s4 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f727(s4);
+            s0 = peg$f835(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -74394,11 +83915,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 5);
-        if (s1.toLowerCase() === peg$c83) {
+        if (s1.toLowerCase() === peg$c87) {
           peg$currPos += (5);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e88); }
+          if (peg$silentFails === 0) { peg$fail(peg$e92); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -74422,7 +83943,7 @@ function peg$parse(input, options) {
             s4 = peg$parseFunctionCall();
             if (s4 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f728(s4);
+              s0 = peg$f836(s4);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -74438,11 +83959,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 5);
-          if (s1.toLowerCase() === peg$c83) {
+          if (s1.toLowerCase() === peg$c87) {
             peg$currPos += (5);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e88); }
+            if (peg$silentFails === 0) { peg$fail(peg$e92); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -74466,7 +83987,7 @@ function peg$parse(input, options) {
               s4 = peg$parseIdentifier();
               if (s4 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f729(s4);
+                s0 = peg$f837(s4);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -74491,7 +84012,7 @@ function peg$parse(input, options) {
   function peg$parseColumnTransformerReplace() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
 
-    const key = peg$currPos * 466 + 401;
+    const key = peg$currPos * 508 + 443;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -74502,11 +84023,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c70) {
+    if (s1.toLowerCase() === peg$c74) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e75); }
+      if (peg$silentFails === 0) { peg$fail(peg$e79); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -74528,11 +84049,11 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         s3 = peg$parse_();
         s4 = input.substr(peg$currPos, 6);
-        if (s4.toLowerCase() === peg$c353) {
+        if (s4.toLowerCase() === peg$c383) {
           peg$currPos += (6);
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e392); }
+          if (peg$silentFails === 0) { peg$fail(peg$e423); }
         }
         if (s4 !== peg$FAILED) {
           s5 = peg$currPos;
@@ -74554,11 +84075,11 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s7 = peg$c21;
+              s7 = peg$c25;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
@@ -74566,15 +84087,15 @@ function peg$parse(input, options) {
               if (s9 !== peg$FAILED) {
                 s10 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 41) {
-                  s11 = peg$c22;
+                  s11 = peg$c26;
                   peg$currPos++;
                 } else {
                   s11 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
                 if (s11 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f730(s9);
+                  s0 = peg$f838(s9);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -74606,11 +84127,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 7);
-      if (s1.toLowerCase() === peg$c70) {
+      if (s1.toLowerCase() === peg$c74) {
         peg$currPos += (7);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e75); }
+        if (peg$silentFails === 0) { peg$fail(peg$e79); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -74632,11 +84153,11 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           s3 = peg$parse_();
           s4 = input.substr(peg$currPos, 6);
-          if (s4.toLowerCase() === peg$c353) {
+          if (s4.toLowerCase() === peg$c383) {
             peg$currPos += (6);
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e392); }
+            if (peg$silentFails === 0) { peg$fail(peg$e423); }
           }
           if (s4 !== peg$FAILED) {
             s5 = peg$currPos;
@@ -74660,7 +84181,7 @@ function peg$parse(input, options) {
               s7 = peg$parseReplaceItem();
               if (s7 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f731(s7);
+                s0 = peg$f839(s7);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -74684,11 +84205,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = input.substr(peg$currPos, 7);
-        if (s1.toLowerCase() === peg$c70) {
+        if (s1.toLowerCase() === peg$c74) {
           peg$currPos += (7);
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e75); }
+          if (peg$silentFails === 0) { peg$fail(peg$e79); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -74710,11 +84231,11 @@ function peg$parse(input, options) {
           if (s2 !== peg$FAILED) {
             s3 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s4 = peg$c21;
+              s4 = peg$c25;
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s4 !== peg$FAILED) {
               s5 = peg$parse_();
@@ -74722,15 +84243,15 @@ function peg$parse(input, options) {
               if (s6 !== peg$FAILED) {
                 s7 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 41) {
-                  s8 = peg$c22;
+                  s8 = peg$c26;
                   peg$currPos++;
                 } else {
                   s8 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
                 if (s8 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s0 = peg$f732(s6);
+                  s0 = peg$f840(s6);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -74754,11 +84275,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           s1 = input.substr(peg$currPos, 7);
-          if (s1.toLowerCase() === peg$c70) {
+          if (s1.toLowerCase() === peg$c74) {
             peg$currPos += (7);
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e75); }
+            if (peg$silentFails === 0) { peg$fail(peg$e79); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -74782,7 +84303,7 @@ function peg$parse(input, options) {
               s4 = peg$parseReplaceItem();
               if (s4 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f733(s4);
+                s0 = peg$f841(s4);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -74807,7 +84328,7 @@ function peg$parse(input, options) {
   function peg$parseReplaceItemList() {
     let s0, s1, s2, s3, s4, s5, s6, s7;
 
-    const key = peg$currPos * 466 + 402;
+    const key = peg$currPos * 508 + 444;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -74823,11 +84344,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 44) {
-        s5 = peg$c15;
+        s5 = peg$c24;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        if (peg$silentFails === 0) { peg$fail(peg$e28); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -74848,11 +84369,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
-          s5 = peg$c15;
+          s5 = peg$c24;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -74870,7 +84391,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f734(s1, s2);
+      s0 = peg$f842(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -74884,7 +84405,7 @@ function peg$parse(input, options) {
   function peg$parseReplaceItem() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 403;
+    const key = peg$currPos * 508 + 445;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -74903,7 +84424,7 @@ function peg$parse(input, options) {
         s5 = peg$parseIdentifier();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f735(s1, s5);
+          s0 = peg$f843(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -74925,7 +84446,7 @@ function peg$parse(input, options) {
   function peg$parseColumnsExpr() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
 
-    const key = peg$currPos * 466 + 404;
+    const key = peg$currPos * 508 + 446;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -74941,11 +84462,11 @@ function peg$parse(input, options) {
       s3 = peg$currPos;
       s4 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 46) {
-        s5 = peg$c35;
+        s5 = peg$c39;
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s5 !== peg$FAILED) {
         s6 = peg$parse_();
@@ -74953,20 +84474,20 @@ function peg$parse(input, options) {
         peg$silentFails++;
         s8 = peg$currPos;
         s9 = input.substr(peg$currPos, 7);
-        if (s9.toLowerCase() === peg$c354) {
+        if (s9.toLowerCase() === peg$c117) {
           peg$currPos += (7);
         } else {
           s9 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e393); }
+          if (peg$silentFails === 0) { peg$fail(peg$e123); }
         }
         if (s9 !== peg$FAILED) {
           s10 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 40) {
-            s11 = peg$c21;
+            s11 = peg$c25;
             peg$currPos++;
           } else {
             s11 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s11 !== peg$FAILED) {
             s9 = [s9, s10, s11];
@@ -74990,7 +84511,7 @@ function peg$parse(input, options) {
           s8 = peg$parseColumnRefCont();
           if (s8 !== peg$FAILED) {
             peg$savedPos = s3;
-            s3 = peg$f736(s1, s8);
+            s3 = peg$f844(s1, s8);
           } else {
             peg$currPos = s3;
             s3 = peg$FAILED;
@@ -75008,11 +84529,11 @@ function peg$parse(input, options) {
         s3 = peg$currPos;
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 46) {
-          s5 = peg$c35;
+          s5 = peg$c39;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e39); }
+          if (peg$silentFails === 0) { peg$fail(peg$e43); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
@@ -75020,20 +84541,20 @@ function peg$parse(input, options) {
           peg$silentFails++;
           s8 = peg$currPos;
           s9 = input.substr(peg$currPos, 7);
-          if (s9.toLowerCase() === peg$c354) {
+          if (s9.toLowerCase() === peg$c117) {
             peg$currPos += (7);
           } else {
             s9 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e393); }
+            if (peg$silentFails === 0) { peg$fail(peg$e123); }
           }
           if (s9 !== peg$FAILED) {
             s10 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 40) {
-              s11 = peg$c21;
+              s11 = peg$c25;
               peg$currPos++;
             } else {
               s11 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              if (peg$silentFails === 0) { peg$fail(peg$e29); }
             }
             if (s11 !== peg$FAILED) {
               s9 = [s9, s10, s11];
@@ -75057,7 +84578,7 @@ function peg$parse(input, options) {
             s8 = peg$parseColumnRefCont();
             if (s8 !== peg$FAILED) {
               peg$savedPos = s3;
-              s3 = peg$f736(s1, s8);
+              s3 = peg$f844(s1, s8);
             } else {
               peg$currPos = s3;
               s3 = peg$FAILED;
@@ -75073,29 +84594,29 @@ function peg$parse(input, options) {
       }
       s3 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 46) {
-        s4 = peg$c35;
+        s4 = peg$c39;
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s4 !== peg$FAILED) {
         s5 = peg$parse_();
         s6 = input.substr(peg$currPos, 7);
-        if (s6.toLowerCase() === peg$c354) {
+        if (s6.toLowerCase() === peg$c117) {
           peg$currPos += (7);
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e393); }
+          if (peg$silentFails === 0) { peg$fail(peg$e123); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$parse_();
           if (input.charCodeAt(peg$currPos) === 40) {
-            s8 = peg$c21;
+            s8 = peg$c25;
             peg$currPos++;
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            if (peg$silentFails === 0) { peg$fail(peg$e29); }
           }
           if (s8 !== peg$FAILED) {
             s9 = peg$parse_();
@@ -75103,11 +84624,11 @@ function peg$parse(input, options) {
             if (s10 !== peg$FAILED) {
               s11 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 41) {
-                s12 = peg$c22;
+                s12 = peg$c26;
                 peg$currPos++;
               } else {
                 s12 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e26); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
               if (s12 !== peg$FAILED) {
                 s13 = [];
@@ -75135,7 +84656,7 @@ function peg$parse(input, options) {
                   }
                 }
                 peg$savedPos = s0;
-                s0 = peg$f737(s1, s2, s10, s13);
+                s0 = peg$f845(s1, s2, s10, s13);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -75163,20 +84684,20 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = input.substr(peg$currPos, 7);
-      if (s1.toLowerCase() === peg$c354) {
+      if (s1.toLowerCase() === peg$c117) {
         peg$currPos += (7);
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e393); }
+        if (peg$silentFails === 0) { peg$fail(peg$e123); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 40) {
-          s3 = peg$c21;
+          s3 = peg$c25;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s3 !== peg$FAILED) {
           s4 = peg$parse_();
@@ -75184,11 +84705,11 @@ function peg$parse(input, options) {
           if (s5 !== peg$FAILED) {
             s6 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s7 = peg$c22;
+              s7 = peg$c26;
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s7 !== peg$FAILED) {
               s8 = peg$parse_();
@@ -75219,7 +84740,7 @@ function peg$parse(input, options) {
                   }
                 }
                 peg$savedPos = s0;
-                s0 = peg$f738(s5, s9, s10);
+                s0 = peg$f846(s5, s9, s10);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -75250,7 +84771,7 @@ function peg$parse(input, options) {
   function peg$parseIntegerLiteral() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    const key = peg$currPos * 466 + 405;
+    const key = peg$currPos * 508 + 447;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -75288,11 +84809,11 @@ function peg$parse(input, options) {
       s4 = [];
       s5 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 95) {
-        s6 = peg$c212;
+        s6 = peg$c245;
         peg$currPos++;
       } else {
         s6 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e222); }
+        if (peg$silentFails === 0) { peg$fail(peg$e257); }
       }
       if (s6 !== peg$FAILED) {
         s7 = [];
@@ -75332,11 +84853,11 @@ function peg$parse(input, options) {
         s4.push(s5);
         s5 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 95) {
-          s6 = peg$c212;
+          s6 = peg$c245;
           peg$currPos++;
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e222); }
+          if (peg$silentFails === 0) { peg$fail(peg$e257); }
         }
         if (s6 !== peg$FAILED) {
           s7 = [];
@@ -75388,11 +84909,11 @@ function peg$parse(input, options) {
       s2 = peg$currPos;
       peg$silentFails++;
       s3 = input.charAt(peg$currPos);
-      if (peg$r8.test(s3)) {
+      if (peg$r5.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e184); }
+        if (peg$silentFails === 0) { peg$fail(peg$e129); }
       }
       peg$silentFails--;
       if (s3 === peg$FAILED) {
@@ -75403,7 +84924,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f739(s1);
+        s0 = peg$f847(s1);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -75421,7 +84942,7 @@ function peg$parse(input, options) {
   function peg$parseStringLiteral() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 406;
+    const key = peg$currPos * 508 + 448;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -75432,11 +84953,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 8216) {
-      s1 = peg$c355;
+      s1 = peg$c384;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e394); }
+      if (peg$silentFails === 0) { peg$fail(peg$e424); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
@@ -75446,15 +84967,15 @@ function peg$parse(input, options) {
         s3 = peg$parseUnicodeQuoteChar();
       }
       if (input.charCodeAt(peg$currPos) === 8217) {
-        s3 = peg$c356;
+        s3 = peg$c385;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e395); }
+        if (peg$silentFails === 0) { peg$fail(peg$e425); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f740(s2);
+        s0 = peg$f848(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -75466,11 +84987,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 39) {
-        s1 = peg$c108;
+        s1 = peg$c99;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e113); }
+        if (peg$silentFails === 0) { peg$fail(peg$e104); }
       }
       if (s1 !== peg$FAILED) {
         s2 = [];
@@ -75480,15 +85001,15 @@ function peg$parse(input, options) {
           s3 = peg$parseStringChar();
         }
         if (input.charCodeAt(peg$currPos) === 39) {
-          s3 = peg$c108;
+          s3 = peg$c99;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e113); }
+          if (peg$silentFails === 0) { peg$fail(peg$e104); }
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f741(s2);
+          s0 = peg$f849(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -75507,7 +85028,7 @@ function peg$parse(input, options) {
   function peg$parseStringChar() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 407;
+    const key = peg$currPos * 508 + 449;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -75517,214 +85038,214 @@ function peg$parse(input, options) {
     }
 
     s0 = peg$currPos;
-    if (input.substr(peg$currPos, 2) === peg$c109) {
-      s1 = peg$c109;
+    if (input.substr(peg$currPos, 2) === peg$c100) {
+      s1 = peg$c100;
       peg$currPos += 2;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e114); }
+      if (peg$silentFails === 0) { peg$fail(peg$e105); }
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f742();
+      s1 = peg$f850();
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
-      if (input.substr(peg$currPos, 2) === peg$c357) {
-        s1 = peg$c357;
+      if (input.substr(peg$currPos, 2) === peg$c386) {
+        s1 = peg$c386;
         peg$currPos += 2;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e396); }
+        if (peg$silentFails === 0) { peg$fail(peg$e426); }
       }
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f743();
+        s1 = peg$f851();
       }
       s0 = s1;
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
-        if (input.substr(peg$currPos, 2) === peg$c358) {
-          s1 = peg$c358;
+        if (input.substr(peg$currPos, 2) === peg$c387) {
+          s1 = peg$c387;
           peg$currPos += 2;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e397); }
+          if (peg$silentFails === 0) { peg$fail(peg$e427); }
         }
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f744();
+          s1 = peg$f852();
         }
         s0 = s1;
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
-          if (input.substr(peg$currPos, 2) === peg$c359) {
-            s1 = peg$c359;
+          if (input.substr(peg$currPos, 2) === peg$c388) {
+            s1 = peg$c388;
             peg$currPos += 2;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e398); }
+            if (peg$silentFails === 0) { peg$fail(peg$e428); }
           }
           if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
-            s1 = peg$f745();
+            s1 = peg$f853();
           }
           s0 = s1;
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
-            if (input.substr(peg$currPos, 2) === peg$c111) {
-              s1 = peg$c111;
+            if (input.substr(peg$currPos, 2) === peg$c102) {
+              s1 = peg$c102;
               peg$currPos += 2;
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e116); }
+              if (peg$silentFails === 0) { peg$fail(peg$e107); }
             }
             if (s1 !== peg$FAILED) {
               peg$savedPos = s0;
-              s1 = peg$f746();
+              s1 = peg$f854();
             }
             s0 = s1;
             if (s0 === peg$FAILED) {
               s0 = peg$currPos;
-              if (input.substr(peg$currPos, 2) === peg$c360) {
-                s1 = peg$c360;
+              if (input.substr(peg$currPos, 2) === peg$c389) {
+                s1 = peg$c389;
                 peg$currPos += 2;
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e399); }
+                if (peg$silentFails === 0) { peg$fail(peg$e429); }
               }
               if (s1 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s1 = peg$f747();
+                s1 = peg$f855();
               }
               s0 = s1;
               if (s0 === peg$FAILED) {
                 s0 = peg$currPos;
-                if (input.substr(peg$currPos, 2) === peg$c361) {
-                  s1 = peg$c361;
+                if (input.substr(peg$currPos, 2) === peg$c390) {
+                  s1 = peg$c390;
                   peg$currPos += 2;
                 } else {
                   s1 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e400); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e430); }
                 }
                 if (s1 !== peg$FAILED) {
                   peg$savedPos = s0;
-                  s1 = peg$f748();
+                  s1 = peg$f856();
                 }
                 s0 = s1;
                 if (s0 === peg$FAILED) {
                   s0 = peg$currPos;
-                  if (input.substr(peg$currPos, 2) === peg$c362) {
-                    s1 = peg$c362;
+                  if (input.substr(peg$currPos, 2) === peg$c391) {
+                    s1 = peg$c391;
                     peg$currPos += 2;
                   } else {
                     s1 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e401); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e431); }
                   }
                   if (s1 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s1 = peg$f749();
+                    s1 = peg$f857();
                   }
                   s0 = s1;
                   if (s0 === peg$FAILED) {
                     s0 = peg$currPos;
-                    if (input.substr(peg$currPos, 2) === peg$c363) {
-                      s1 = peg$c363;
+                    if (input.substr(peg$currPos, 2) === peg$c392) {
+                      s1 = peg$c392;
                       peg$currPos += 2;
                     } else {
                       s1 = peg$FAILED;
-                      if (peg$silentFails === 0) { peg$fail(peg$e402); }
+                      if (peg$silentFails === 0) { peg$fail(peg$e432); }
                     }
                     if (s1 !== peg$FAILED) {
                       peg$savedPos = s0;
-                      s1 = peg$f750();
+                      s1 = peg$f858();
                     }
                     s0 = s1;
                     if (s0 === peg$FAILED) {
                       s0 = peg$currPos;
-                      if (input.substr(peg$currPos, 2) === peg$c364) {
-                        s1 = peg$c364;
+                      if (input.substr(peg$currPos, 2) === peg$c393) {
+                        s1 = peg$c393;
                         peg$currPos += 2;
                       } else {
                         s1 = peg$FAILED;
-                        if (peg$silentFails === 0) { peg$fail(peg$e403); }
+                        if (peg$silentFails === 0) { peg$fail(peg$e433); }
                       }
                       if (s1 !== peg$FAILED) {
                         peg$savedPos = s0;
-                        s1 = peg$f751();
+                        s1 = peg$f859();
                       }
                       s0 = s1;
                       if (s0 === peg$FAILED) {
                         s0 = peg$currPos;
-                        if (input.substr(peg$currPos, 2) === peg$c365) {
-                          s1 = peg$c365;
+                        if (input.substr(peg$currPos, 2) === peg$c394) {
+                          s1 = peg$c394;
                           peg$currPos += 2;
                         } else {
                           s1 = peg$FAILED;
-                          if (peg$silentFails === 0) { peg$fail(peg$e404); }
+                          if (peg$silentFails === 0) { peg$fail(peg$e434); }
                         }
                         if (s1 !== peg$FAILED) {
                           peg$savedPos = s0;
-                          s1 = peg$f752();
+                          s1 = peg$f860();
                         }
                         s0 = s1;
                         if (s0 === peg$FAILED) {
                           s0 = peg$currPos;
-                          if (input.substr(peg$currPos, 2) === peg$c110) {
-                            s1 = peg$c110;
+                          if (input.substr(peg$currPos, 2) === peg$c101) {
+                            s1 = peg$c101;
                             peg$currPos += 2;
                           } else {
                             s1 = peg$FAILED;
-                            if (peg$silentFails === 0) { peg$fail(peg$e115); }
+                            if (peg$silentFails === 0) { peg$fail(peg$e106); }
                           }
                           if (s1 !== peg$FAILED) {
                             peg$savedPos = s0;
-                            s1 = peg$f753();
+                            s1 = peg$f861();
                           }
                           s0 = s1;
                           if (s0 === peg$FAILED) {
                             s0 = peg$currPos;
-                            if (input.substr(peg$currPos, 2) === peg$c366) {
-                              s1 = peg$c366;
+                            if (input.substr(peg$currPos, 2) === peg$c395) {
+                              s1 = peg$c395;
                               peg$currPos += 2;
                             } else {
                               s1 = peg$FAILED;
-                              if (peg$silentFails === 0) { peg$fail(peg$e405); }
+                              if (peg$silentFails === 0) { peg$fail(peg$e435); }
                             }
                             if (s1 !== peg$FAILED) {
                               peg$savedPos = s0;
-                              s1 = peg$f754();
+                              s1 = peg$f862();
                             }
                             s0 = s1;
                             if (s0 === peg$FAILED) {
                               s0 = peg$currPos;
-                              if (input.substr(peg$currPos, 2) === peg$c367) {
-                                s1 = peg$c367;
+                              if (input.substr(peg$currPos, 2) === peg$c396) {
+                                s1 = peg$c396;
                                 peg$currPos += 2;
                               } else {
                                 s1 = peg$FAILED;
-                                if (peg$silentFails === 0) { peg$fail(peg$e406); }
+                                if (peg$silentFails === 0) { peg$fail(peg$e436); }
                               }
                               if (s1 !== peg$FAILED) {
                                 s2 = input.charAt(peg$currPos);
-                                if (peg$r32.test(s2)) {
+                                if (peg$r34.test(s2)) {
                                   peg$currPos++;
                                 } else {
                                   s2 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e384); }
                                 }
                                 if (s2 !== peg$FAILED) {
                                   s3 = input.charAt(peg$currPos);
-                                  if (peg$r32.test(s3)) {
+                                  if (peg$r34.test(s3)) {
                                     peg$currPos++;
                                   } else {
                                     s3 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e352); }
+                                    if (peg$silentFails === 0) { peg$fail(peg$e384); }
                                   }
                                   if (s3 !== peg$FAILED) {
                                     peg$savedPos = s0;
-                                    s0 = peg$f755(s2, s3);
+                                    s0 = peg$f863(s2, s3);
                                   } else {
                                     peg$currPos = s0;
                                     s0 = peg$FAILED;
@@ -75740,23 +85261,23 @@ function peg$parse(input, options) {
                               if (s0 === peg$FAILED) {
                                 s0 = peg$currPos;
                                 if (input.charCodeAt(peg$currPos) === 92) {
-                                  s1 = peg$c368;
+                                  s1 = peg$c397;
                                   peg$currPos++;
                                 } else {
                                   s1 = peg$FAILED;
-                                  if (peg$silentFails === 0) { peg$fail(peg$e407); }
+                                  if (peg$silentFails === 0) { peg$fail(peg$e437); }
                                 }
                                 if (s1 !== peg$FAILED) {
                                   s2 = input.charAt(peg$currPos);
-                                  if (peg$r8.test(s2)) {
+                                  if (peg$r5.test(s2)) {
                                     peg$currPos++;
                                   } else {
                                     s2 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e184); }
+                                    if (peg$silentFails === 0) { peg$fail(peg$e129); }
                                   }
                                   if (s2 !== peg$FAILED) {
                                     peg$savedPos = s0;
-                                    s0 = peg$f756(s2);
+                                    s0 = peg$f864(s2);
                                   } else {
                                     peg$currPos = s0;
                                     s0 = peg$FAILED;
@@ -75768,11 +85289,11 @@ function peg$parse(input, options) {
                                 if (s0 === peg$FAILED) {
                                   s0 = peg$currPos;
                                   if (input.charCodeAt(peg$currPos) === 92) {
-                                    s1 = peg$c368;
+                                    s1 = peg$c397;
                                     peg$currPos++;
                                   } else {
                                     s1 = peg$FAILED;
-                                    if (peg$silentFails === 0) { peg$fail(peg$e407); }
+                                    if (peg$silentFails === 0) { peg$fail(peg$e437); }
                                   }
                                   if (s1 !== peg$FAILED) {
                                     if (input.length > peg$currPos) {
@@ -75780,11 +85301,11 @@ function peg$parse(input, options) {
                                       peg$currPos++;
                                     } else {
                                       s2 = peg$FAILED;
-                                      if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                                      if (peg$silentFails === 0) { peg$fail(peg$e24); }
                                     }
                                     if (s2 !== peg$FAILED) {
                                       peg$savedPos = s0;
-                                      s0 = peg$f757(s2);
+                                      s0 = peg$f865(s2);
                                     } else {
                                       peg$currPos = s0;
                                       s0 = peg$FAILED;
@@ -75796,15 +85317,15 @@ function peg$parse(input, options) {
                                   if (s0 === peg$FAILED) {
                                     s0 = peg$currPos;
                                     s1 = input.charAt(peg$currPos);
-                                    if (peg$r37.test(s1)) {
+                                    if (peg$r38.test(s1)) {
                                       peg$currPos++;
                                     } else {
                                       s1 = peg$FAILED;
-                                      if (peg$silentFails === 0) { peg$fail(peg$e408); }
+                                      if (peg$silentFails === 0) { peg$fail(peg$e438); }
                                     }
                                     if (s1 !== peg$FAILED) {
                                       peg$savedPos = s0;
-                                      s1 = peg$f758();
+                                      s1 = peg$f866();
                                     }
                                     s0 = s1;
                                   }
@@ -75832,7 +85353,7 @@ function peg$parse(input, options) {
   function peg$parseUnicodeQuoteChar() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 408;
+    const key = peg$currPos * 508 + 450;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -75843,21 +85364,21 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 92) {
-      s1 = peg$c368;
+      s1 = peg$c397;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e407); }
+      if (peg$silentFails === 0) { peg$fail(peg$e437); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
       peg$silentFails++;
       if (input.charCodeAt(peg$currPos) === 8217) {
-        s3 = peg$c356;
+        s3 = peg$c385;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e395); }
+        if (peg$silentFails === 0) { peg$fail(peg$e425); }
       }
       peg$silentFails--;
       if (s3 !== peg$FAILED) {
@@ -75868,7 +85389,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f759();
+        s0 = peg$f867();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -75880,15 +85401,15 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 92) {
-        s1 = peg$c368;
+        s1 = peg$c397;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e407); }
+        if (peg$silentFails === 0) { peg$fail(peg$e437); }
       }
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f760();
+        s1 = peg$f868();
       }
       s0 = s1;
       if (s0 === peg$FAILED) {
@@ -75896,11 +85417,11 @@ function peg$parse(input, options) {
         s1 = peg$currPos;
         peg$silentFails++;
         if (input.charCodeAt(peg$currPos) === 8217) {
-          s2 = peg$c356;
+          s2 = peg$c385;
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e395); }
+          if (peg$silentFails === 0) { peg$fail(peg$e425); }
         }
         peg$silentFails--;
         if (s2 === peg$FAILED) {
@@ -75915,11 +85436,11 @@ function peg$parse(input, options) {
             peg$currPos++;
           } else {
             s2 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e21); }
+            if (peg$silentFails === 0) { peg$fail(peg$e24); }
           }
           if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f761(s2);
+            s0 = peg$f869(s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -75939,7 +85460,7 @@ function peg$parse(input, options) {
   function peg$parseQueryParamIdentifier() {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
-    const key = peg$currPos * 466 + 409;
+    const key = peg$currPos * 508 + 451;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -75950,11 +85471,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 123) {
-      s1 = peg$c172;
+      s1 = peg$c210;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e180); }
+      if (peg$silentFails === 0) { peg$fail(peg$e221); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
@@ -75989,20 +85510,20 @@ function peg$parse(input, options) {
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 58) {
-          s5 = peg$c263;
+          s5 = peg$c293;
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e282); }
+          if (peg$silentFails === 0) { peg$fail(peg$e314); }
         }
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           s7 = input.substr(peg$currPos, 10);
-          if (s7.toLowerCase() === peg$c369) {
+          if (s7.toLowerCase() === peg$c398) {
             peg$currPos += (10);
           } else {
             s7 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e409); }
+            if (peg$silentFails === 0) { peg$fail(peg$e439); }
           }
           if (s7 !== peg$FAILED) {
             s8 = peg$currPos;
@@ -76024,15 +85545,15 @@ function peg$parse(input, options) {
             if (s8 !== peg$FAILED) {
               s9 = peg$parse_();
               if (input.charCodeAt(peg$currPos) === 125) {
-                s10 = peg$c173;
+                s10 = peg$c211;
                 peg$currPos++;
               } else {
                 s10 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e182); }
+                if (peg$silentFails === 0) { peg$fail(peg$e223); }
               }
               if (s10 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f762(s3);
+                s0 = peg$f870(s3);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -76066,7 +85587,7 @@ function peg$parse(input, options) {
   function peg$parseTableRef() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 410;
+    const key = peg$currPos * 508 + 452;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -76083,11 +85604,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 46) {
-        s3 = peg$c35;
+        s3 = peg$c39;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        if (peg$silentFails === 0) { peg$fail(peg$e43); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
@@ -76097,7 +85618,7 @@ function peg$parse(input, options) {
         }
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f763(s1, s5);
+          s0 = peg$f871(s1, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -76118,7 +85639,7 @@ function peg$parse(input, options) {
       }
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f764(s1);
+        s1 = peg$f872(s1);
       }
       s0 = s1;
     }
@@ -76131,7 +85652,7 @@ function peg$parse(input, options) {
   function peg$parseIdentifier() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 411;
+    const key = peg$currPos * 508 + 453;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -76144,11 +85665,11 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     s2 = peg$currPos;
     s3 = input.charAt(peg$currPos);
-    if (peg$r8.test(s3)) {
+    if (peg$r5.test(s3)) {
       peg$currPos++;
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e184); }
+      if (peg$silentFails === 0) { peg$fail(peg$e129); }
     }
     if (s3 !== peg$FAILED) {
       s4 = [];
@@ -76182,7 +85703,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = peg$currPos;
-      s2 = peg$f765(s1);
+      s2 = peg$f873(s1);
       if (s2) {
         s2 = undefined;
       } else {
@@ -76190,7 +85711,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f766(s1);
+        s0 = peg$f874(s1);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -76202,11 +85723,11 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 34) {
-        s1 = peg$c255;
+        s1 = peg$c285;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e274); }
+        if (peg$silentFails === 0) { peg$fail(peg$e306); }
       }
       if (s1 !== peg$FAILED) {
         s2 = [];
@@ -76216,15 +85737,15 @@ function peg$parse(input, options) {
           s3 = peg$parseDoubleQuotedChar();
         }
         if (input.charCodeAt(peg$currPos) === 34) {
-          s3 = peg$c255;
+          s3 = peg$c285;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e274); }
+          if (peg$silentFails === 0) { peg$fail(peg$e306); }
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f767(s2);
+          s0 = peg$f875(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -76236,11 +85757,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 96) {
-          s1 = peg$c219;
+          s1 = peg$c124;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e231); }
+          if (peg$silentFails === 0) { peg$fail(peg$e133); }
         }
         if (s1 !== peg$FAILED) {
           s2 = [];
@@ -76250,15 +85771,15 @@ function peg$parse(input, options) {
             s3 = peg$parseBacktickChar();
           }
           if (input.charCodeAt(peg$currPos) === 96) {
-            s3 = peg$c219;
+            s3 = peg$c124;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e231); }
+            if (peg$silentFails === 0) { peg$fail(peg$e133); }
           }
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f768(s2);
+            s0 = peg$f876(s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -76270,11 +85791,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 8220) {
-            s1 = peg$c370;
+            s1 = peg$c399;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e410); }
+            if (peg$silentFails === 0) { peg$fail(peg$e440); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -76283,11 +85804,11 @@ function peg$parse(input, options) {
             s5 = peg$currPos;
             peg$silentFails++;
             if (input.charCodeAt(peg$currPos) === 8221) {
-              s6 = peg$c371;
+              s6 = peg$c400;
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e411); }
+              if (peg$silentFails === 0) { peg$fail(peg$e441); }
             }
             peg$silentFails--;
             if (s6 === peg$FAILED) {
@@ -76302,7 +85823,7 @@ function peg$parse(input, options) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                if (peg$silentFails === 0) { peg$fail(peg$e24); }
               }
               if (s6 !== peg$FAILED) {
                 s5 = [s5, s6];
@@ -76321,11 +85842,11 @@ function peg$parse(input, options) {
               s5 = peg$currPos;
               peg$silentFails++;
               if (input.charCodeAt(peg$currPos) === 8221) {
-                s6 = peg$c371;
+                s6 = peg$c400;
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e411); }
+                if (peg$silentFails === 0) { peg$fail(peg$e441); }
               }
               peg$silentFails--;
               if (s6 === peg$FAILED) {
@@ -76340,7 +85861,7 @@ function peg$parse(input, options) {
                   peg$currPos++;
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e24); }
                 }
                 if (s6 !== peg$FAILED) {
                   s5 = [s5, s6];
@@ -76356,15 +85877,15 @@ function peg$parse(input, options) {
             }
             s2 = input.substring(s2, peg$currPos);
             if (input.charCodeAt(peg$currPos) === 8221) {
-              s3 = peg$c371;
+              s3 = peg$c400;
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e411); }
+              if (peg$silentFails === 0) { peg$fail(peg$e441); }
             }
             if (s3 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f769(s2);
+              s0 = peg$f877(s2);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -76385,7 +85906,7 @@ function peg$parse(input, options) {
   function peg$parseLambdaParamName() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 412;
+    const key = peg$currPos * 508 + 454;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -76398,11 +85919,11 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     s2 = peg$currPos;
     s3 = input.charAt(peg$currPos);
-    if (peg$r8.test(s3)) {
+    if (peg$r5.test(s3)) {
       peg$currPos++;
     } else {
       s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e184); }
+      if (peg$silentFails === 0) { peg$fail(peg$e129); }
     }
     if (s3 !== peg$FAILED) {
       s4 = [];
@@ -76436,17 +85957,17 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f770(s1);
+      s1 = peg$f878(s1);
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 34) {
-        s1 = peg$c255;
+        s1 = peg$c285;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e274); }
+        if (peg$silentFails === 0) { peg$fail(peg$e306); }
       }
       if (s1 !== peg$FAILED) {
         s2 = [];
@@ -76456,15 +85977,15 @@ function peg$parse(input, options) {
           s3 = peg$parseDoubleQuotedChar();
         }
         if (input.charCodeAt(peg$currPos) === 34) {
-          s3 = peg$c255;
+          s3 = peg$c285;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e274); }
+          if (peg$silentFails === 0) { peg$fail(peg$e306); }
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f771(s2);
+          s0 = peg$f879(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -76476,11 +85997,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 96) {
-          s1 = peg$c219;
+          s1 = peg$c124;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e231); }
+          if (peg$silentFails === 0) { peg$fail(peg$e133); }
         }
         if (s1 !== peg$FAILED) {
           s2 = [];
@@ -76490,15 +86011,15 @@ function peg$parse(input, options) {
             s3 = peg$parseBacktickChar();
           }
           if (input.charCodeAt(peg$currPos) === 96) {
-            s3 = peg$c219;
+            s3 = peg$c124;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e231); }
+            if (peg$silentFails === 0) { peg$fail(peg$e133); }
           }
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f772(s2);
+            s0 = peg$f880(s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -76510,11 +86031,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 8220) {
-            s1 = peg$c370;
+            s1 = peg$c399;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e410); }
+            if (peg$silentFails === 0) { peg$fail(peg$e440); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -76523,11 +86044,11 @@ function peg$parse(input, options) {
             s5 = peg$currPos;
             peg$silentFails++;
             if (input.charCodeAt(peg$currPos) === 8221) {
-              s6 = peg$c371;
+              s6 = peg$c400;
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e411); }
+              if (peg$silentFails === 0) { peg$fail(peg$e441); }
             }
             peg$silentFails--;
             if (s6 === peg$FAILED) {
@@ -76542,7 +86063,7 @@ function peg$parse(input, options) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                if (peg$silentFails === 0) { peg$fail(peg$e24); }
               }
               if (s6 !== peg$FAILED) {
                 s5 = [s5, s6];
@@ -76561,11 +86082,11 @@ function peg$parse(input, options) {
               s5 = peg$currPos;
               peg$silentFails++;
               if (input.charCodeAt(peg$currPos) === 8221) {
-                s6 = peg$c371;
+                s6 = peg$c400;
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e411); }
+                if (peg$silentFails === 0) { peg$fail(peg$e441); }
               }
               peg$silentFails--;
               if (s6 === peg$FAILED) {
@@ -76580,7 +86101,7 @@ function peg$parse(input, options) {
                   peg$currPos++;
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e24); }
                 }
                 if (s6 !== peg$FAILED) {
                   s5 = [s5, s6];
@@ -76596,15 +86117,15 @@ function peg$parse(input, options) {
             }
             s2 = input.substring(s2, peg$currPos);
             if (input.charCodeAt(peg$currPos) === 8221) {
-              s3 = peg$c371;
+              s3 = peg$c400;
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e411); }
+              if (peg$silentFails === 0) { peg$fail(peg$e441); }
             }
             if (s3 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f773(s2);
+              s0 = peg$f881(s2);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -76625,7 +86146,7 @@ function peg$parse(input, options) {
   function peg$parseAliasName() {
     let s0, s1, s2, s3, s4, s5, s6;
 
-    const key = peg$currPos * 466 + 413;
+    const key = peg$currPos * 508 + 455;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -76636,33 +86157,33 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.charAt(peg$currPos);
-    if (peg$r38.test(s1)) {
+    if (peg$r6.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e412); }
+      if (peg$silentFails === 0) { peg$fail(peg$e131); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
       s3 = input.charAt(peg$currPos);
-      if (peg$r34.test(s3)) {
+      if (peg$r7.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e387); }
+        if (peg$silentFails === 0) { peg$fail(peg$e132); }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
         s3 = input.charAt(peg$currPos);
-        if (peg$r34.test(s3)) {
+        if (peg$r7.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e387); }
+          if (peg$silentFails === 0) { peg$fail(peg$e132); }
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f774(s1, s2);
+      s0 = peg$f882(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -76679,24 +86200,24 @@ function peg$parse(input, options) {
       if (s1 !== peg$FAILED) {
         s2 = [];
         s3 = input.charAt(peg$currPos);
-        if (peg$r34.test(s3)) {
+        if (peg$r7.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e387); }
+          if (peg$silentFails === 0) { peg$fail(peg$e132); }
         }
         while (s3 !== peg$FAILED) {
           s2.push(s3);
           s3 = input.charAt(peg$currPos);
-          if (peg$r34.test(s3)) {
+          if (peg$r7.test(s3)) {
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e387); }
+            if (peg$silentFails === 0) { peg$fail(peg$e132); }
           }
         }
         peg$savedPos = s0;
-        s0 = peg$f775(s1, s2);
+        s0 = peg$f883(s1, s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -76704,11 +86225,11 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 34) {
-          s1 = peg$c255;
+          s1 = peg$c285;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e274); }
+          if (peg$silentFails === 0) { peg$fail(peg$e306); }
         }
         if (s1 !== peg$FAILED) {
           s2 = [];
@@ -76718,15 +86239,15 @@ function peg$parse(input, options) {
             s3 = peg$parseDoubleQuotedChar();
           }
           if (input.charCodeAt(peg$currPos) === 34) {
-            s3 = peg$c255;
+            s3 = peg$c285;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e274); }
+            if (peg$silentFails === 0) { peg$fail(peg$e306); }
           }
           if (s3 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f776(s2);
+            s0 = peg$f884(s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -76738,11 +86259,11 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 96) {
-            s1 = peg$c219;
+            s1 = peg$c124;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e231); }
+            if (peg$silentFails === 0) { peg$fail(peg$e133); }
           }
           if (s1 !== peg$FAILED) {
             s2 = [];
@@ -76752,15 +86273,15 @@ function peg$parse(input, options) {
               s3 = peg$parseBacktickChar();
             }
             if (input.charCodeAt(peg$currPos) === 96) {
-              s3 = peg$c219;
+              s3 = peg$c124;
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e231); }
+              if (peg$silentFails === 0) { peg$fail(peg$e133); }
             }
             if (s3 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f777(s2);
+              s0 = peg$f885(s2);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -76772,11 +86293,11 @@ function peg$parse(input, options) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 8220) {
-              s1 = peg$c370;
+              s1 = peg$c399;
               peg$currPos++;
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e410); }
+              if (peg$silentFails === 0) { peg$fail(peg$e440); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -76785,11 +86306,11 @@ function peg$parse(input, options) {
               s5 = peg$currPos;
               peg$silentFails++;
               if (input.charCodeAt(peg$currPos) === 8221) {
-                s6 = peg$c371;
+                s6 = peg$c400;
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e411); }
+                if (peg$silentFails === 0) { peg$fail(peg$e441); }
               }
               peg$silentFails--;
               if (s6 === peg$FAILED) {
@@ -76804,7 +86325,7 @@ function peg$parse(input, options) {
                   peg$currPos++;
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e24); }
                 }
                 if (s6 !== peg$FAILED) {
                   s5 = [s5, s6];
@@ -76823,11 +86344,11 @@ function peg$parse(input, options) {
                 s5 = peg$currPos;
                 peg$silentFails++;
                 if (input.charCodeAt(peg$currPos) === 8221) {
-                  s6 = peg$c371;
+                  s6 = peg$c400;
                   peg$currPos++;
                 } else {
                   s6 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e411); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e441); }
                 }
                 peg$silentFails--;
                 if (s6 === peg$FAILED) {
@@ -76842,7 +86363,7 @@ function peg$parse(input, options) {
                     peg$currPos++;
                   } else {
                     s6 = peg$FAILED;
-                    if (peg$silentFails === 0) { peg$fail(peg$e21); }
+                    if (peg$silentFails === 0) { peg$fail(peg$e24); }
                   }
                   if (s6 !== peg$FAILED) {
                     s5 = [s5, s6];
@@ -76858,15 +86379,15 @@ function peg$parse(input, options) {
               }
               s2 = input.substring(s2, peg$currPos);
               if (input.charCodeAt(peg$currPos) === 8221) {
-                s3 = peg$c371;
+                s3 = peg$c400;
                 peg$currPos++;
               } else {
                 s3 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e411); }
+                if (peg$silentFails === 0) { peg$fail(peg$e441); }
               }
               if (s3 !== peg$FAILED) {
                 peg$savedPos = s0;
-                s0 = peg$f778(s2);
+                s0 = peg$f886(s2);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -76888,7 +86409,7 @@ function peg$parse(input, options) {
   function peg$parseDoubleQuotedChar() {
     let s0, s1, s2;
 
-    const key = peg$currPos * 466 + 414;
+    const key = peg$currPos * 508 + 456;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -76898,54 +86419,54 @@ function peg$parse(input, options) {
     }
 
     s0 = peg$currPos;
-    if (input.substr(peg$currPos, 2) === peg$c372) {
-      s1 = peg$c372;
+    if (input.substr(peg$currPos, 2) === peg$c401) {
+      s1 = peg$c401;
       peg$currPos += 2;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e413); }
+      if (peg$silentFails === 0) { peg$fail(peg$e442); }
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f779();
+      s1 = peg$f887();
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
-      if (input.substr(peg$currPos, 2) === peg$c366) {
-        s1 = peg$c366;
+      if (input.substr(peg$currPos, 2) === peg$c395) {
+        s1 = peg$c395;
         peg$currPos += 2;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e405); }
+        if (peg$silentFails === 0) { peg$fail(peg$e435); }
       }
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f780();
+        s1 = peg$f888();
       }
       s0 = s1;
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
-        if (input.substr(peg$currPos, 2) === peg$c111) {
-          s1 = peg$c111;
+        if (input.substr(peg$currPos, 2) === peg$c102) {
+          s1 = peg$c102;
           peg$currPos += 2;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e116); }
+          if (peg$silentFails === 0) { peg$fail(peg$e107); }
         }
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f781();
+          s1 = peg$f889();
         }
         s0 = s1;
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 92) {
-            s1 = peg$c368;
+            s1 = peg$c397;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e407); }
+            if (peg$silentFails === 0) { peg$fail(peg$e437); }
           }
           if (s1 !== peg$FAILED) {
             if (input.length > peg$currPos) {
@@ -76953,11 +86474,11 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s2 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e21); }
+              if (peg$silentFails === 0) { peg$fail(peg$e24); }
             }
             if (s2 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f782(s2);
+              s0 = peg$f890(s2);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -76973,11 +86494,11 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e414); }
+              if (peg$silentFails === 0) { peg$fail(peg$e443); }
             }
             if (s1 !== peg$FAILED) {
               peg$savedPos = s0;
-              s1 = peg$f783();
+              s1 = peg$f891();
             }
             s0 = s1;
           }
@@ -76993,7 +86514,7 @@ function peg$parse(input, options) {
   function peg$parseBacktickChar() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 415;
+    const key = peg$currPos * 508 + 457;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77003,44 +86524,44 @@ function peg$parse(input, options) {
     }
 
     s0 = peg$currPos;
-    if (input.substr(peg$currPos, 2) === peg$c373) {
-      s1 = peg$c373;
+    if (input.substr(peg$currPos, 2) === peg$c402) {
+      s1 = peg$c402;
       peg$currPos += 2;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e415); }
+      if (peg$silentFails === 0) { peg$fail(peg$e444); }
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f784();
+      s1 = peg$f892();
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
-      if (input.substr(peg$currPos, 2) === peg$c367) {
-        s1 = peg$c367;
+      if (input.substr(peg$currPos, 2) === peg$c396) {
+        s1 = peg$c396;
         peg$currPos += 2;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e406); }
+        if (peg$silentFails === 0) { peg$fail(peg$e436); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
         s3 = peg$currPos;
         s4 = input.charAt(peg$currPos);
-        if (peg$r32.test(s4)) {
+        if (peg$r34.test(s4)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e352); }
+          if (peg$silentFails === 0) { peg$fail(peg$e384); }
         }
         if (s4 !== peg$FAILED) {
           s5 = input.charAt(peg$currPos);
-          if (peg$r32.test(s5)) {
+          if (peg$r34.test(s5)) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e352); }
+            if (peg$silentFails === 0) { peg$fail(peg$e384); }
           }
           if (s5 !== peg$FAILED) {
             s4 = [s4, s5];
@@ -77060,7 +86581,7 @@ function peg$parse(input, options) {
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f785(s2);
+          s0 = peg$f893(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -77071,26 +86592,26 @@ function peg$parse(input, options) {
       }
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
-        if (input.substr(peg$currPos, 2) === peg$c365) {
-          s1 = peg$c365;
+        if (input.substr(peg$currPos, 2) === peg$c394) {
+          s1 = peg$c394;
           peg$currPos += 2;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e404); }
+          if (peg$silentFails === 0) { peg$fail(peg$e434); }
         }
         if (s1 !== peg$FAILED) {
           peg$savedPos = s0;
-          s1 = peg$f786();
+          s1 = peg$f894();
         }
         s0 = s1;
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 92) {
-            s1 = peg$c368;
+            s1 = peg$c397;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e407); }
+            if (peg$silentFails === 0) { peg$fail(peg$e437); }
           }
           if (s1 !== peg$FAILED) {
             if (input.length > peg$currPos) {
@@ -77098,11 +86619,11 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s2 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e21); }
+              if (peg$silentFails === 0) { peg$fail(peg$e24); }
             }
             if (s2 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f787(s2);
+              s0 = peg$f895(s2);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -77118,11 +86639,11 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e416); }
+              if (peg$silentFails === 0) { peg$fail(peg$e445); }
             }
             if (s1 !== peg$FAILED) {
               peg$savedPos = s0;
-              s1 = peg$f788();
+              s1 = peg$f896();
             }
             s0 = s1;
           }
@@ -77138,7 +86659,7 @@ function peg$parse(input, options) {
   function peg$parseKW_WITH() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 416;
+    const key = peg$currPos * 508 + 458;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77149,11 +86670,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c53) {
+    if (s1.toLowerCase() === peg$c57) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e58); }
+      if (peg$silentFails === 0) { peg$fail(peg$e62); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77192,7 +86713,7 @@ function peg$parse(input, options) {
   function peg$parseKW_AS() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 417;
+    const key = peg$currPos * 508 + 459;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77246,7 +86767,7 @@ function peg$parse(input, options) {
   function peg$parseKW_SELECT() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 418;
+    const key = peg$currPos * 508 + 460;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77257,11 +86778,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c131) {
+    if (s1.toLowerCase() === peg$c135) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e137); }
+      if (peg$silentFails === 0) { peg$fail(peg$e144); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77300,7 +86821,7 @@ function peg$parse(input, options) {
   function peg$parseKW_FROM() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 419;
+    const key = peg$currPos * 508 + 461;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77311,11 +86832,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c69) {
+    if (s1.toLowerCase() === peg$c73) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e74); }
+      if (peg$silentFails === 0) { peg$fail(peg$e78); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77354,7 +86875,7 @@ function peg$parse(input, options) {
   function peg$parseKW_PREWHERE() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 420;
+    const key = peg$currPos * 508 + 462;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77365,11 +86886,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c242) {
+    if (s1.toLowerCase() === peg$c273) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e257); }
+      if (peg$silentFails === 0) { peg$fail(peg$e290); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77408,7 +86929,7 @@ function peg$parse(input, options) {
   function peg$parseKW_WHERE() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 421;
+    const key = peg$currPos * 508 + 463;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77419,11 +86940,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c61) {
+    if (s1.toLowerCase() === peg$c65) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e66); }
+      if (peg$silentFails === 0) { peg$fail(peg$e70); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77462,7 +86983,7 @@ function peg$parse(input, options) {
   function peg$parseKW_GROUP() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 422;
+    const key = peg$currPos * 508 + 464;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77473,11 +86994,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c226) {
+    if (s1.toLowerCase() === peg$c258) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e240); }
+      if (peg$silentFails === 0) { peg$fail(peg$e274); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77516,7 +87037,7 @@ function peg$parse(input, options) {
   function peg$parseKW_ORDER() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 423;
+    const key = peg$currPos * 508 + 465;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77527,11 +87048,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c79) {
+    if (s1.toLowerCase() === peg$c83) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e84); }
+      if (peg$silentFails === 0) { peg$fail(peg$e88); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77570,7 +87091,7 @@ function peg$parse(input, options) {
   function peg$parseKW_BY() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 424;
+    const key = peg$currPos * 508 + 466;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77581,11 +87102,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c80) {
+    if (s1.toLowerCase() === peg$c84) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e85); }
+      if (peg$silentFails === 0) { peg$fail(peg$e89); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77624,7 +87145,7 @@ function peg$parse(input, options) {
   function peg$parseKW_HAVING() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 425;
+    const key = peg$currPos * 508 + 467;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77635,11 +87156,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c243) {
+    if (s1.toLowerCase() === peg$c274) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e258); }
+      if (peg$silentFails === 0) { peg$fail(peg$e291); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77678,7 +87199,7 @@ function peg$parse(input, options) {
   function peg$parseKW_LIMIT() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 426;
+    const key = peg$currPos * 508 + 468;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77689,11 +87210,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c244) {
+    if (s1.toLowerCase() === peg$c152) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e259); }
+      if (peg$silentFails === 0) { peg$fail(peg$e161); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77732,7 +87253,7 @@ function peg$parse(input, options) {
   function peg$parseKW_OFFSET() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 427;
+    const key = peg$currPos * 508 + 469;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77743,11 +87264,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c245) {
+    if (s1.toLowerCase() === peg$c275) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e260); }
+      if (peg$silentFails === 0) { peg$fail(peg$e292); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77786,7 +87307,7 @@ function peg$parse(input, options) {
   function peg$parseKW_AND() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 428;
+    const key = peg$currPos * 508 + 470;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77797,11 +87318,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c145) {
+    if (s1.toLowerCase() === peg$c189) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e151); }
+      if (peg$silentFails === 0) { peg$fail(peg$e198); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77840,7 +87361,7 @@ function peg$parse(input, options) {
   function peg$parseKW_OR() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 429;
+    const key = peg$currPos * 508 + 471;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77851,11 +87372,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c149) {
+    if (s1.toLowerCase() === peg$c193) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e155); }
+      if (peg$silentFails === 0) { peg$fail(peg$e202); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77894,7 +87415,7 @@ function peg$parse(input, options) {
   function peg$parseKW_ASC() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 430;
+    const key = peg$currPos * 508 + 472;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77905,11 +87426,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c164) {
+    if (s1.toLowerCase() === peg$c208) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e170); }
+      if (peg$silentFails === 0) { peg$fail(peg$e217); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77930,7 +87451,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f789(s1);
+        s0 = peg$f897(s1);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -77948,7 +87469,7 @@ function peg$parse(input, options) {
   function peg$parseKW_DESC() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 431;
+    const key = peg$currPos * 508 + 473;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -77959,11 +87480,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c130) {
+    if (s1.toLowerCase() === peg$c184) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e136); }
+      if (peg$silentFails === 0) { peg$fail(peg$e193); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -77984,7 +87505,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f790(s1);
+        s0 = peg$f898(s1);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -78002,7 +87523,7 @@ function peg$parse(input, options) {
   function peg$parseKW_IN() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 432;
+    const key = peg$currPos * 508 + 474;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78013,11 +87534,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c89) {
+    if (s1.toLowerCase() === peg$c93) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e94); }
+      if (peg$silentFails === 0) { peg$fail(peg$e98); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78056,7 +87577,7 @@ function peg$parse(input, options) {
   function peg$parseKW_NOT() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 433;
+    const key = peg$currPos * 508 + 475;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78067,11 +87588,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c26) {
+    if (s1.toLowerCase() === peg$c30) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e30); }
+      if (peg$silentFails === 0) { peg$fail(peg$e34); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78110,7 +87631,7 @@ function peg$parse(input, options) {
   function peg$parseKW_DISTINCT() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 434;
+    const key = peg$currPos * 508 + 476;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78121,11 +87642,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c237) {
+    if (s1.toLowerCase() === peg$c268) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e251); }
+      if (peg$silentFails === 0) { peg$fail(peg$e284); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78164,7 +87685,7 @@ function peg$parse(input, options) {
   function peg$parseKW_FINAL() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 435;
+    const key = peg$currPos * 508 + 477;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78175,11 +87696,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c125) {
+    if (s1.toLowerCase() === peg$c158) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e131); }
+      if (peg$silentFails === 0) { peg$fail(peg$e167); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78218,7 +87739,7 @@ function peg$parse(input, options) {
   function peg$parseKW_JOIN() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 436;
+    const key = peg$currPos * 508 + 478;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78229,11 +87750,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c374) {
+    if (s1.toLowerCase() === peg$c403) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e417); }
+      if (peg$silentFails === 0) { peg$fail(peg$e446); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78272,7 +87793,7 @@ function peg$parse(input, options) {
   function peg$parseKW_INNER() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 437;
+    const key = peg$currPos * 508 + 479;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78283,11 +87804,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c150) {
+    if (s1.toLowerCase() === peg$c194) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e156); }
+      if (peg$silentFails === 0) { peg$fail(peg$e203); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78326,7 +87847,7 @@ function peg$parse(input, options) {
   function peg$parseKW_LEFT() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 438;
+    const key = peg$currPos * 508 + 480;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78337,11 +87858,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c375) {
+    if (s1.toLowerCase() === peg$c404) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e418); }
+      if (peg$silentFails === 0) { peg$fail(peg$e447); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78380,7 +87901,7 @@ function peg$parse(input, options) {
   function peg$parseKW_RIGHT() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 439;
+    const key = peg$currPos * 508 + 481;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78391,11 +87912,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c376) {
+    if (s1.toLowerCase() === peg$c405) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e419); }
+      if (peg$silentFails === 0) { peg$fail(peg$e448); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78434,7 +87955,7 @@ function peg$parse(input, options) {
   function peg$parseKW_FULL() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 440;
+    const key = peg$currPos * 508 + 482;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78445,11 +87966,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c377) {
+    if (s1.toLowerCase() === peg$c150) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e420); }
+      if (peg$silentFails === 0) { peg$fail(peg$e159); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78488,7 +88009,7 @@ function peg$parse(input, options) {
   function peg$parseKW_CROSS() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 441;
+    const key = peg$currPos * 508 + 483;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78499,11 +88020,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c378) {
+    if (s1.toLowerCase() === peg$c406) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e421); }
+      if (peg$silentFails === 0) { peg$fail(peg$e449); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78542,7 +88063,7 @@ function peg$parse(input, options) {
   function peg$parseKW_OUTER() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 442;
+    const key = peg$currPos * 508 + 484;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78553,11 +88074,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c379) {
+    if (s1.toLowerCase() === peg$c407) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e422); }
+      if (peg$silentFails === 0) { peg$fail(peg$e450); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78596,7 +88117,7 @@ function peg$parse(input, options) {
   function peg$parseKW_ARRAY() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 443;
+    const key = peg$currPos * 508 + 485;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78607,11 +88128,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c380) {
+    if (s1.toLowerCase() === peg$c408) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e423); }
+      if (peg$silentFails === 0) { peg$fail(peg$e451); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78650,7 +88171,7 @@ function peg$parse(input, options) {
   function peg$parseKW_ON() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 444;
+    const key = peg$currPos * 508 + 486;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78661,11 +88182,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 2);
-    if (s1.toLowerCase() === peg$c103) {
+    if (s1.toLowerCase() === peg$c94) {
       peg$currPos += (2);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e108); }
+      if (peg$silentFails === 0) { peg$fail(peg$e99); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78704,7 +88225,7 @@ function peg$parse(input, options) {
   function peg$parseKW_USING() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 445;
+    const key = peg$currPos * 508 + 487;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78715,11 +88236,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c187) {
+    if (s1.toLowerCase() === peg$c136) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e197); }
+      if (peg$silentFails === 0) { peg$fail(peg$e145); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78758,7 +88279,7 @@ function peg$parse(input, options) {
   function peg$parseKW_SETTINGS() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 446;
+    const key = peg$currPos * 508 + 488;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78769,11 +88290,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 8);
-    if (s1.toLowerCase() === peg$c43) {
+    if (s1.toLowerCase() === peg$c47) {
       peg$currPos += (8);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e47); }
+      if (peg$silentFails === 0) { peg$fail(peg$e51); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78812,7 +88333,7 @@ function peg$parse(input, options) {
   function peg$parseKW_TOTALS() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 447;
+    const key = peg$currPos * 508 + 489;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78823,11 +88344,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c381) {
+    if (s1.toLowerCase() === peg$c409) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e424); }
+      if (peg$silentFails === 0) { peg$fail(peg$e452); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78866,7 +88387,7 @@ function peg$parse(input, options) {
   function peg$parseKW_ALL() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 448;
+    const key = peg$currPos * 508 + 490;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78920,7 +88441,7 @@ function peg$parse(input, options) {
   function peg$parseKW_ANY() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 449;
+    const key = peg$currPos * 508 + 491;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78931,11 +88452,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 3);
-    if (s1.toLowerCase() === peg$c177) {
+    if (s1.toLowerCase() === peg$c215) {
       peg$currPos += (3);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e187); }
+      if (peg$silentFails === 0) { peg$fail(peg$e227); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -78974,7 +88495,7 @@ function peg$parse(input, options) {
   function peg$parseKW_SEMI() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 450;
+    const key = peg$currPos * 508 + 492;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -78985,11 +88506,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c382) {
+    if (s1.toLowerCase() === peg$c410) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e425); }
+      if (peg$silentFails === 0) { peg$fail(peg$e453); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -79028,7 +88549,7 @@ function peg$parse(input, options) {
   function peg$parseKW_ANTI() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 451;
+    const key = peg$currPos * 508 + 493;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79039,11 +88560,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c383) {
+    if (s1.toLowerCase() === peg$c411) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e426); }
+      if (peg$silentFails === 0) { peg$fail(peg$e454); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -79082,7 +88603,7 @@ function peg$parse(input, options) {
   function peg$parseKW_ASOF() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 452;
+    const key = peg$currPos * 508 + 494;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79093,11 +88614,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c384) {
+    if (s1.toLowerCase() === peg$c412) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e427); }
+      if (peg$silentFails === 0) { peg$fail(peg$e455); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -79136,7 +88657,7 @@ function peg$parse(input, options) {
   function peg$parseKW_GLOBAL() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 453;
+    const key = peg$currPos * 508 + 495;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79147,11 +88668,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c385) {
+    if (s1.toLowerCase() === peg$c413) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e428); }
+      if (peg$silentFails === 0) { peg$fail(peg$e456); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -79190,7 +88711,7 @@ function peg$parse(input, options) {
   function peg$parseKW_UNION() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 454;
+    const key = peg$currPos * 508 + 496;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79201,11 +88722,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c246) {
+    if (s1.toLowerCase() === peg$c276) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e261); }
+      if (peg$silentFails === 0) { peg$fail(peg$e293); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -79244,7 +88765,7 @@ function peg$parse(input, options) {
   function peg$parseKW_LIKE() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 455;
+    const key = peg$currPos * 508 + 497;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79255,11 +88776,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 4);
-    if (s1.toLowerCase() === peg$c123) {
+    if (s1.toLowerCase() === peg$c172) {
       peg$currPos += (4);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e129); }
+      if (peg$silentFails === 0) { peg$fail(peg$e181); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -79298,7 +88819,7 @@ function peg$parse(input, options) {
   function peg$parseKW_ILIKE() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 456;
+    const key = peg$currPos * 508 + 498;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79309,11 +88830,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 5);
-    if (s1.toLowerCase() === peg$c386) {
+    if (s1.toLowerCase() === peg$c171) {
       peg$currPos += (5);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e429); }
+      if (peg$silentFails === 0) { peg$fail(peg$e180); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -79352,7 +88873,7 @@ function peg$parse(input, options) {
   function peg$parseKW_BETWEEN() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 457;
+    const key = peg$currPos * 508 + 499;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79363,11 +88884,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 7);
-    if (s1.toLowerCase() === peg$c282) {
+    if (s1.toLowerCase() === peg$c312) {
       peg$currPos += (7);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e304); }
+      if (peg$silentFails === 0) { peg$fail(peg$e336); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -79406,7 +88927,7 @@ function peg$parse(input, options) {
   function peg$parseKW_FORMAT() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 458;
+    const key = peg$currPos * 508 + 500;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79417,11 +88938,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c120) {
+    if (s1.toLowerCase() === peg$c177) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e126); }
+      if (peg$silentFails === 0) { peg$fail(peg$e186); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -79460,7 +88981,7 @@ function peg$parse(input, options) {
   function peg$parseKW_WINDOW() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 459;
+    const key = peg$currPos * 508 + 501;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79471,11 +88992,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.substr(peg$currPos, 6);
-    if (s1.toLowerCase() === peg$c214) {
+    if (s1.toLowerCase() === peg$c247) {
       peg$currPos += (6);
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e224); }
+      if (peg$silentFails === 0) { peg$fail(peg$e259); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -79514,7 +89035,7 @@ function peg$parse(input, options) {
   function peg$parse_() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 460;
+    const key = peg$currPos * 508 + 502;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79533,7 +89054,7 @@ function peg$parse(input, options) {
       s3 = peg$parse_NLC();
     }
     peg$savedPos = s0;
-    s0 = peg$f791(s1, s2);
+    s0 = peg$f899(s1, s2);
     peg$silentFails--;
 
     peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -79544,7 +89065,7 @@ function peg$parse(input, options) {
   function peg$parse_HWS() {
     let s0, s1, s2, s3, s4;
 
-    const key = peg$currPos * 466 + 461;
+    const key = peg$currPos * 508 + 503;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79562,7 +89083,7 @@ function peg$parse(input, options) {
       peg$currPos++;
     } else {
       s4 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e430); }
+      if (peg$silentFails === 0) { peg$fail(peg$e457); }
     }
     if (s4 !== peg$FAILED) {
       while (s4 !== peg$FAILED) {
@@ -79572,7 +89093,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e430); }
+          if (peg$silentFails === 0) { peg$fail(peg$e457); }
         }
       }
     } else {
@@ -79580,7 +89101,7 @@ function peg$parse(input, options) {
     }
     if (s3 !== peg$FAILED) {
       peg$savedPos = s2;
-      s3 = peg$f792();
+      s3 = peg$f900();
     }
     s2 = s3;
     if (s2 === peg$FAILED) {
@@ -79598,7 +89119,7 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e430); }
+        if (peg$silentFails === 0) { peg$fail(peg$e457); }
       }
       if (s4 !== peg$FAILED) {
         while (s4 !== peg$FAILED) {
@@ -79608,7 +89129,7 @@ function peg$parse(input, options) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e430); }
+            if (peg$silentFails === 0) { peg$fail(peg$e457); }
           }
         }
       } else {
@@ -79616,7 +89137,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s2;
-        s3 = peg$f792();
+        s3 = peg$f900();
       }
       s2 = s3;
       if (s2 === peg$FAILED) {
@@ -79627,7 +89148,7 @@ function peg$parse(input, options) {
       }
     }
     peg$savedPos = s0;
-    s1 = peg$f793(s1);
+    s1 = peg$f901(s1);
     s0 = s1;
 
     peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -79638,7 +89159,7 @@ function peg$parse(input, options) {
   function peg$parse_NLC() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 462;
+    const key = peg$currPos * 508 + 504;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79654,7 +89175,7 @@ function peg$parse(input, options) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e117); }
+      if (peg$silentFails === 0) { peg$fail(peg$e108); }
     }
     if (s2 !== peg$FAILED) {
       while (s2 !== peg$FAILED) {
@@ -79664,7 +89185,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e117); }
+          if (peg$silentFails === 0) { peg$fail(peg$e108); }
         }
       }
     } else {
@@ -79679,7 +89200,7 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e430); }
+        if (peg$silentFails === 0) { peg$fail(peg$e457); }
       }
       if (s5 !== peg$FAILED) {
         while (s5 !== peg$FAILED) {
@@ -79689,7 +89210,7 @@ function peg$parse(input, options) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e430); }
+            if (peg$silentFails === 0) { peg$fail(peg$e457); }
           }
         }
       } else {
@@ -79697,7 +89218,7 @@ function peg$parse(input, options) {
       }
       if (s4 !== peg$FAILED) {
         peg$savedPos = s3;
-        s4 = peg$f794();
+        s4 = peg$f902();
       }
       s3 = s4;
       if (s3 === peg$FAILED) {
@@ -79715,7 +89236,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e430); }
+          if (peg$silentFails === 0) { peg$fail(peg$e457); }
         }
         if (s5 !== peg$FAILED) {
           while (s5 !== peg$FAILED) {
@@ -79725,7 +89246,7 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e430); }
+              if (peg$silentFails === 0) { peg$fail(peg$e457); }
             }
           }
         } else {
@@ -79733,7 +89254,7 @@ function peg$parse(input, options) {
         }
         if (s4 !== peg$FAILED) {
           peg$savedPos = s3;
-          s4 = peg$f794();
+          s4 = peg$f902();
         }
         s3 = s4;
         if (s3 === peg$FAILED) {
@@ -79744,7 +89265,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f795(s2);
+      s0 = peg$f903(s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -79758,7 +89279,7 @@ function peg$parse(input, options) {
   function peg$parseSingleLineComment() {
     let s0, s1, s2, s3, s4, s5;
 
-    const key = peg$currPos * 466 + 463;
+    const key = peg$currPos * 508 + 505;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79768,36 +89289,36 @@ function peg$parse(input, options) {
     }
 
     s0 = peg$currPos;
-    if (input.substr(peg$currPos, 2) === peg$c387) {
-      s1 = peg$c387;
+    if (input.substr(peg$currPos, 2) === peg$c414) {
+      s1 = peg$c414;
       peg$currPos += 2;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e431); }
+      if (peg$silentFails === 0) { peg$fail(peg$e458); }
     }
     if (s1 === peg$FAILED) {
-      if (input.substr(peg$currPos, 2) === peg$c388) {
-        s1 = peg$c388;
+      if (input.substr(peg$currPos, 2) === peg$c415) {
+        s1 = peg$c415;
         peg$currPos += 2;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e432); }
+        if (peg$silentFails === 0) { peg$fail(peg$e459); }
       }
       if (s1 === peg$FAILED) {
-        if (input.substr(peg$currPos, 2) === peg$c389) {
-          s1 = peg$c389;
+        if (input.substr(peg$currPos, 2) === peg$c416) {
+          s1 = peg$c416;
           peg$currPos += 2;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e433); }
+          if (peg$silentFails === 0) { peg$fail(peg$e460); }
         }
         if (s1 === peg$FAILED) {
-          if (input.substr(peg$currPos, 2) === peg$c390) {
-            s1 = peg$c390;
+          if (input.substr(peg$currPos, 2) === peg$c417) {
+            s1 = peg$c417;
             peg$currPos += 2;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e434); }
+            if (peg$silentFails === 0) { peg$fail(peg$e461); }
           }
         }
       }
@@ -79812,7 +89333,7 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e435); }
+        if (peg$silentFails === 0) { peg$fail(peg$e462); }
       }
       peg$silentFails--;
       if (s5 === peg$FAILED) {
@@ -79827,7 +89348,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e21); }
+          if (peg$silentFails === 0) { peg$fail(peg$e24); }
         }
         if (s5 !== peg$FAILED) {
           s4 = [s4, s5];
@@ -79850,7 +89371,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e435); }
+          if (peg$silentFails === 0) { peg$fail(peg$e462); }
         }
         peg$silentFails--;
         if (s5 === peg$FAILED) {
@@ -79865,7 +89386,7 @@ function peg$parse(input, options) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e21); }
+            if (peg$silentFails === 0) { peg$fail(peg$e24); }
           }
           if (s5 !== peg$FAILED) {
             s4 = [s4, s5];
@@ -79880,7 +89401,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f796();
+      s0 = peg$f904();
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -79894,7 +89415,7 @@ function peg$parse(input, options) {
   function peg$parseMultiLineComment() {
     let s0, s1, s2, s3;
 
-    const key = peg$currPos * 466 + 464;
+    const key = peg$currPos * 508 + 506;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79904,12 +89425,12 @@ function peg$parse(input, options) {
     }
 
     s0 = peg$currPos;
-    if (input.substr(peg$currPos, 2) === peg$c391) {
-      s1 = peg$c391;
+    if (input.substr(peg$currPos, 2) === peg$c418) {
+      s1 = peg$c418;
       peg$currPos += 2;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e436); }
+      if (peg$silentFails === 0) { peg$fail(peg$e463); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
@@ -79918,16 +89439,16 @@ function peg$parse(input, options) {
         s2.push(s3);
         s3 = peg$parseMultiLineCommentContent();
       }
-      if (input.substr(peg$currPos, 2) === peg$c392) {
-        s3 = peg$c392;
+      if (input.substr(peg$currPos, 2) === peg$c419) {
+        s3 = peg$c419;
         peg$currPos += 2;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e437); }
+        if (peg$silentFails === 0) { peg$fail(peg$e464); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f797();
+        s0 = peg$f905();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -79945,7 +89466,7 @@ function peg$parse(input, options) {
   function peg$parseMultiLineCommentContent() {
     let s0, s1, s2;
 
-    const key = peg$currPos * 466 + 465;
+    const key = peg$currPos * 508 + 507;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -79959,12 +89480,12 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s1 = peg$currPos;
       peg$silentFails++;
-      if (input.substr(peg$currPos, 2) === peg$c392) {
-        s2 = peg$c392;
+      if (input.substr(peg$currPos, 2) === peg$c419) {
+        s2 = peg$c419;
         peg$currPos += 2;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e437); }
+        if (peg$silentFails === 0) { peg$fail(peg$e464); }
       }
       peg$silentFails--;
       if (s2 === peg$FAILED) {
@@ -79979,11 +89500,11 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e21); }
+          if (peg$silentFails === 0) { peg$fail(peg$e24); }
         }
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f798();
+          s0 = peg$f906();
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
diff --git a/src/transform-nodes.ts b/src/transform-nodes.ts
index 977a8b9da..d4fa4889b 100644
--- a/src/transform-nodes.ts
+++ b/src/transform-nodes.ts
@@ -84,6 +84,15 @@ export interface NodePositionMap {
   insert: Statement;
   truncate: Statement;
   drop: Statement;
+  undrop: Statement;
+  backup: Statement;
+  grant: Statement;
+  show: Statement;
+  alterUser: Statement;
+  alterRole: Statement;
+  alterQuota: Statement;
+  alterRowPolicy: Statement;
+  alterSettingsProfile: Statement;
   optimize: Statement;
   describe: Statement;
   showCreate: Statement;
diff --git a/tests/clickhouse-reference/00080_show_tables_and_system_tables.sql.expected.ast.json b/tests/clickhouse-reference/00080_show_tables_and_system_tables.sql.expected.ast.json
index 52a6e6c63..c3726d908 100644
--- a/tests/clickhouse-reference/00080_show_tables_and_system_tables.sql.expected.ast.json
+++ b/tests/clickhouse-reference/00080_show_tables_and_system_tables.sql.expected.ast.json
@@ -72,12 +72,84 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier}"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES IN system WHERE engine LIKE '%System%' AND name IN ('numbers', 'one') AND database = 'system'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": "system",
+      "where": {
+        "kind": "naryExpr",
+        "op": "AND",
+        "operands": [
+          {
+            "kind": "functionCall",
+            "name": "like",
+            "args": [
+              {
+                "kind": "columnRef",
+                "parts": [
+                  "engine"
+                ]
+              },
+              {
+                "kind": "literal",
+                "type": "String",
+                "value": "%System%"
+              }
+            ]
+          },
+          {
+            "kind": "inExpr",
+            "negated": false,
+            "expr": {
+              "kind": "columnRef",
+              "parts": [
+                "name"
+              ]
+            },
+            "values": [
+              {
+                "kind": "literal",
+                "type": "String",
+                "value": "numbers"
+              },
+              {
+                "kind": "literal",
+                "type": "String",
+                "value": "one"
+              }
+            ]
+          },
+          {
+            "kind": "binaryExpr",
+            "op": "=",
+            "left": {
+              "kind": "columnRef",
+              "parts": [
+                "database"
+              ]
+            },
+            "right": {
+              "kind": "literal",
+              "type": "String",
+              "value": "system"
+            }
+          }
+        ]
+      }
+    }
   },
   {
     "kind": "select",
diff --git a/tests/clickhouse-reference/00080_show_tables_and_system_tables.sql.expected.formatted.sql b/tests/clickhouse-reference/00080_show_tables_and_system_tables.sql.expected.formatted.sql
index 9664db5c3..6b89820b0 100644
--- a/tests/clickhouse-reference/00080_show_tables_and_system_tables.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/00080_show_tables_and_system_tables.sql.expected.formatted.sql
@@ -17,7 +17,9 @@ ENGINE = TinyLog;
 
 SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier};
 
-SHOW TABLES IN system WHERE engine LIKE '%System%' AND name IN ('numbers', 'one') AND database = 'system';
+SHOW TABLES FROM `system` WHERE like(engine, '%System%')
+AND name IN ('numbers', 'one')
+AND database = 'system';
 
 SELECT
     name,
diff --git a/tests/clickhouse-reference/00405_output_format_pretty_color.sql.expected.ast.json b/tests/clickhouse-reference/00405_output_format_pretty_color.sql.expected.ast.json
index bc7bfdec7..bdb981fdb 100644
--- a/tests/clickhouse-reference/00405_output_format_pretty_color.sql.expected.ast.json
+++ b/tests/clickhouse-reference/00405_output_format_pretty_color.sql.expected.ast.json
@@ -39,8 +39,11 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW SETTING output_format_pretty_color"
+    "kind": "show",
+    "show": {
+      "type": "setting",
+      "name": "output_format_pretty_color"
+    }
   },
   {
     "kind": "select",
diff --git a/tests/clickhouse-reference/00564_temporary_table_management.sql.expected.ast.json b/tests/clickhouse-reference/00564_temporary_table_management.sql.expected.ast.json
index 5d36a999c..d69ed6aa5 100644
--- a/tests/clickhouse-reference/00564_temporary_table_management.sql.expected.ast.json
+++ b/tests/clickhouse-reference/00564_temporary_table_management.sql.expected.ast.json
@@ -46,8 +46,15 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TEMPORARY TABLES LIKE 'temp_tab'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "temporary": true,
+      "like": {
+        "pattern": "temp_tab"
+      }
+    }
   },
   {
     "kind": "drop",
diff --git a/tests/clickhouse-reference/01012_show_tables_limit.sql.expected.ast.json b/tests/clickhouse-reference/01012_show_tables_limit.sql.expected.ast.json
index 404c18cf6..908380471 100644
--- a/tests/clickhouse-reference/01012_show_tables_limit.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01012_show_tables_limit.sql.expected.ast.json
@@ -144,15 +144,58 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier}"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier} LIMIT 2"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      },
+      "limit": {
+        "kind": "literal",
+        "type": "UInt64",
+        "value": "2"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier} LIMIT 2 * 2"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      },
+      "limit": {
+        "kind": "binaryExpr",
+        "op": "*",
+        "left": {
+          "kind": "literal",
+          "type": "UInt64",
+          "value": "2"
+        },
+        "right": {
+          "kind": "literal",
+          "type": "UInt64",
+          "value": "2"
+        }
+      }
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/01018_ddl_dictionaries_create.sql.expected.ast.json b/tests/clickhouse-reference/01018_ddl_dictionaries_create.sql.expected.ast.json
index 26acf25d2..ec7c6fdb0 100644
--- a/tests/clickhouse-reference/01018_ddl_dictionaries_create.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01018_ddl_dictionaries_create.sql.expected.ast.json
@@ -230,8 +230,15 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW DICTIONARIES FROM db_01018 LIKE 'dict1'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "DICTIONARIES",
+      "from": "db_01018",
+      "like": {
+        "pattern": "dict1"
+      }
+    }
   },
   {
     "kind": "exists",
@@ -475,8 +482,15 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW DICTIONARIES FROM memory_db LIKE 'dict2'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "DICTIONARIES",
+      "from": "memory_db",
+      "like": {
+        "pattern": "dict2"
+      }
+    }
   },
   {
     "kind": "exists",
@@ -662,8 +676,12 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW DICTIONARIES FROM db_01018"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "DICTIONARIES",
+      "from": "db_01018"
+    }
   },
   {
     "kind": "drop",
diff --git a/tests/clickhouse-reference/01033_quota_dcl.sql.expected.ast.json b/tests/clickhouse-reference/01033_quota_dcl.sql.expected.ast.json
index aa02f9896..2341bd571 100644
--- a/tests/clickhouse-reference/01033_quota_dcl.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01033_quota_dcl.sql.expected.ast.json
@@ -1,6 +1,14 @@
 [
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA default"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "default"
+        }
+      ]
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/01053_drop_database_mat_view.sql.expected.ast.json b/tests/clickhouse-reference/01053_drop_database_mat_view.sql.expected.ast.json
index 3d67519dd..9b47e7ae6 100644
--- a/tests/clickhouse-reference/01053_drop_database_mat_view.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01053_drop_database_mat_view.sql.expected.ast.json
@@ -127,8 +127,16 @@
     }
   },
   {
-    "kind": "system",
-    "body": "show tables from {CLICKHOUSE_DATABASE:Identifier}"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      }
+    }
   },
   {
     "kind": "createMaterializedView",
diff --git a/tests/clickhouse-reference/01053_drop_database_mat_view.sql.expected.formatted.sql b/tests/clickhouse-reference/01053_drop_database_mat_view.sql.expected.formatted.sql
index c8cac47ea..9a5502d3d 100644
--- a/tests/clickhouse-reference/01053_drop_database_mat_view.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01053_drop_database_mat_view.sql.expected.formatted.sql
@@ -16,7 +16,7 @@ SELECT
     today() AS day,
     'mystring' AS str;
 
-show tables from {CLICKHOUSE_DATABASE:Identifier};
+SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier};
 
 CREATE MATERIALIZED VIEW {CLICKHOUSE_DATABASE:Identifier}.my_materialized_view
 ENGINE = MergeTree(day, (day), 8192)
diff --git a/tests/clickhouse-reference/01073_grant_and_revoke.sql.expected.ast.json b/tests/clickhouse-reference/01073_grant_and_revoke.sql.expected.ast.json
index d3a641613..ca503a894 100644
--- a/tests/clickhouse-reference/01073_grant_and_revoke.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01073_grant_and_revoke.sql.expected.ast.json
@@ -19,56 +19,255 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER test_user_01073"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "test_user_01073"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW GRANTS FOR test_user_01073"
+    "kind": "show",
+    "show": {
+      "type": "grants",
+      "for": [
+        "test_user_01073"
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON db1.* TO test_user_01073"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db1",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON db2.table TO test_user_01073"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db2",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT(col1) ON db3.table TO test_user_01073"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "col1"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db3",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT(col1, col2) ON db4.table TO test_user_01073"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "col1",
+              "col2"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db4",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT INSERT ON *.* TO test_user_01073"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "INSERT"
+          }
+        ],
+        "target": {
+          "database": "*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT DELETE ON *.* TO test_user_01073"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "DELETE"
+          }
+        ],
+        "target": {
+          "database": "*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT ON db1.* FROM test_user_01073"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db1",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT ON db2.table FROM test_user_01073"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db2",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT ON db3.table FROM test_user_01073"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db3",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT(col2) ON db4.table FROM test_user_01073"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "col2"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db4",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE INSERT ON *.* FROM test_user_01073"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "INSERT"
+          }
+        ],
+        "target": {
+          "database": "*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01073"
+    ]
   },
   {
     "kind": "createRole",
@@ -79,20 +278,83 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON db1.* TO test_role_01073"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db1",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_role_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT(c1, c2, c3, c4, c5) ON db1.table1 FROM test_role_01073"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "c1",
+              "c2",
+              "c3",
+              "c4",
+              "c5"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db1",
+          "table": "table1"
+        }
+      }
+    ],
+    "grantees": [
+      "test_role_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT(c1) ON db1.table2 FROM test_role_01073"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "c1"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db1",
+          "table": "table2"
+        }
+      }
+    ],
+    "grantees": [
+      "test_role_01073"
+    ]
   },
   {
-    "kind": "system",
-    "body": "SHOW GRANTS FOR test_role_01073"
+    "kind": "show",
+    "show": {
+      "type": "grants",
+      "for": [
+        "test_role_01073"
+      ]
+    }
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/01073_show_tables_not_like.sql.expected.ast.json b/tests/clickhouse-reference/01073_show_tables_not_like.sql.expected.ast.json
index 21f2a13a8..86db6d0e0 100644
--- a/tests/clickhouse-reference/01073_show_tables_not_like.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01073_show_tables_not_like.sql.expected.ast.json
@@ -1,11 +1,21 @@
 [
   {
-    "kind": "system",
-    "body": "SHOW TABLES NOT LIKE '%'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "like": {
+        "pattern": "%",
+        "not": true
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES"
+    }
   },
   {
     "kind": "select",
@@ -56,40 +66,120 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES LIKE 'tes%'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "like": {
+        "pattern": "tes%"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES NOT LIKE 'tes%'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "like": {
+        "pattern": "tes%",
+        "not": true
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES LIKE 'tes%1'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "like": {
+        "pattern": "tes%1"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES NOT LIKE 'tes%2'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "like": {
+        "pattern": "tes%2",
+        "not": true
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier}"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier} LIKE 'tes%'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      },
+      "like": {
+        "pattern": "tes%"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier} NOT LIKE 'tes%'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      },
+      "like": {
+        "pattern": "tes%",
+        "not": true
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier} LIKE 'tes%1'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      },
+      "like": {
+        "pattern": "tes%1"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier} NOT LIKE 'tes%2'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      },
+      "like": {
+        "pattern": "tes%2",
+        "not": true
+      }
+    }
   },
   {
     "kind": "drop",
diff --git a/tests/clickhouse-reference/01074_partial_revokes.sql.expected.ast.json b/tests/clickhouse-reference/01074_partial_revokes.sql.expected.ast.json
index 9d4a95191..abdca687c 100644
--- a/tests/clickhouse-reference/01074_partial_revokes.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01074_partial_revokes.sql.expected.ast.json
@@ -25,40 +25,180 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON *.* TO test_user_01074"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01074"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT ON db.* FROM test_user_01074"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01074"
+    ]
   },
   {
-    "kind": "system",
-    "body": "SHOW GRANTS FOR test_user_01074"
+    "kind": "show",
+    "show": {
+      "type": "grants",
+      "for": [
+        "test_user_01074"
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT ON *.* FROM test_user_01074"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01074"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON db.* TO test_user_01074"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01074"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT ON db.table FROM test_user_01074"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01074"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON db.table TO test_user_01074"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01074"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT(col1) ON db.table FROM test_user_01074"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "col1"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01074"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT(col1, col2) ON db.table FROM test_user_01074"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "col1",
+              "col2"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01074"
+    ]
   },
   {
     "kind": "select",
@@ -100,16 +240,74 @@
     "format": "Pretty"
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON *.* TO test_user_01074 WITH GRANT OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01074"
+    ],
+    "withOptions": [
+      "GRANT"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE GRANT OPTION FOR SELECT(col1) ON db.table FROM test_user_01074"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "col1"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01074"
+    ],
+    "optionFor": "GRANT"
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON db.* TO test_user_01074 WITH GRANT OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01074"
+    ],
+    "withOptions": [
+      "GRANT"
+    ]
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/01075_allowed_client_hosts.sql.expected.ast.json b/tests/clickhouse-reference/01075_allowed_client_hosts.sql.expected.ast.json
index c05cc5d9a..7442326e3 100644
--- a/tests/clickhouse-reference/01075_allowed_client_hosts.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01075_allowed_client_hosts.sql.expected.ast.json
@@ -15,60 +15,280 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER test_user_01075"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "test_user_01075"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 HOST ANY"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "any"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 HOST NONE"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "none"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 HOST LOCAL"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "local"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 HOST IP '192.168.23.15'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "ip",
+            "value": "192.168.23.15"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 HOST IP '2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "ip",
+            "value": "2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 ADD HOST IP '127.0.0.1'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "mode": "ADD",
+        "hosts": [
+          {
+            "kind": "ip",
+            "value": "127.0.0.1"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 DROP HOST IP '2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "mode": "DROP",
+        "hosts": [
+          {
+            "kind": "ip",
+            "value": "2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 DROP HOST NAME 'localhost'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "mode": "DROP",
+        "hosts": [
+          {
+            "kind": "name",
+            "value": "localhost"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 HOST LIKE '@.somesite.com'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "like",
+            "value": "@.somesite.com"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 HOST REGEXP '.*\\.anothersite\\.com'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "regexp",
+            "value": ".*\\\\.anothersite\\\\.com"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 HOST REGEXP '.*\\.anothersite\\.com', '.*\\.anothersite\\.org'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "regexp",
+            "value": ".*\\\\.anothersite\\\\.com"
+          },
+          {
+            "kind": "regexp",
+            "value": ".*\\\\.anothersite\\\\.org"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 HOST REGEXP '.*\\.anothersite2\\.com', REGEXP '.*\\.anothersite2\\.org'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "regexp",
+            "value": ".*\\\\.anothersite2\\\\.com"
+          },
+          {
+            "kind": "regexp",
+            "value": ".*\\\\.anothersite2\\\\.org"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075 HOST REGEXP '.*\\.anothersite3\\.com' HOST REGEXP '.*\\.anothersite3\\.org'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "regexp",
+            "value": ".*\\\\.anothersite3\\\\.com"
+          }
+        ]
+      },
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "regexp",
+            "value": ".*\\\\.anothersite3\\\\.org"
+          }
+        ]
+      }
+    ]
   },
   {
     "kind": "system",
@@ -84,24 +304,76 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER test_user_01075_x@localhost"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "test_user_01075_x",
+          "host": "localhost"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075_x@localhost RENAME TO test_user_01075_x@'%'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075_x",
+        "host": "localhost"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "rename",
+        "to": {
+          "name": "test_user_01075_x",
+          "host": "'%'"
+        }
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER test_user_01075_x"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "test_user_01075_x"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER USER test_user_01075_x RENAME TO test_user_01075_x@'192.168.23.15'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test_user_01075_x"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "rename",
+        "to": {
+          "name": "test_user_01075_x",
+          "host": "'192.168.23.15'"
+        }
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER 'test_user_01075_x@192.168.23.15'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "'test_user_01075_x@192.168.23.15'"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/01075_allowed_client_hosts.sql.expected.formatted.sql b/tests/clickhouse-reference/01075_allowed_client_hosts.sql.expected.formatted.sql
index bd4628510..51d69ccd8 100644
--- a/tests/clickhouse-reference/01075_allowed_client_hosts.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01075_allowed_client_hosts.sql.expected.formatted.sql
@@ -23,13 +23,13 @@ ALTER USER test_user_01075 DROP HOST NAME 'localhost';
 
 ALTER USER test_user_01075 HOST LIKE '@.somesite.com';
 
-ALTER USER test_user_01075 HOST REGEXP '.*\.anothersite\.com';
+ALTER USER test_user_01075 HOST REGEXP '.*\\.anothersite\\.com';
 
-ALTER USER test_user_01075 HOST REGEXP '.*\.anothersite\.com', '.*\.anothersite\.org';
+ALTER USER test_user_01075 HOST REGEXP '.*\\.anothersite\\.com', REGEXP '.*\\.anothersite\\.org';
 
-ALTER USER test_user_01075 HOST REGEXP '.*\.anothersite2\.com', REGEXP '.*\.anothersite2\.org';
+ALTER USER test_user_01075 HOST REGEXP '.*\\.anothersite2\\.com', REGEXP '.*\\.anothersite2\\.org';
 
-ALTER USER test_user_01075 HOST REGEXP '.*\.anothersite3\.com' HOST REGEXP '.*\.anothersite3\.org';
+ALTER USER test_user_01075 HOST REGEXP '.*\\.anothersite3\\.com' HOST REGEXP '.*\\.anothersite3\\.org';
 
 DROP USER test_user_01075;
 
diff --git a/tests/clickhouse-reference/01119_weird_user_names.sql.expected.ast.json b/tests/clickhouse-reference/01119_weird_user_names.sql.expected.ast.json
index e224fb0e1..9bc60b5ae 100644
--- a/tests/clickhouse-reference/01119_weird_user_names.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01119_weird_user_names.sql.expected.ast.json
@@ -78,12 +78,36 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "alter user `test 01119` rename to \" spaces \""
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "test 01119"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "rename",
+        "to": {
+          "name": " spaces "
+        }
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "alter user \" spaces \" rename to \" INTERSERVER SECRET \"",
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": " spaces "
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "rename",
+        "to": {
+          "name": " INTERSERVER SECRET "
+        }
+      }
+    ],
     "trailingComments": [
       "-- { serverError BAD_ARGUMENTS }"
     ]
diff --git a/tests/clickhouse-reference/01119_weird_user_names.sql.expected.formatted.sql b/tests/clickhouse-reference/01119_weird_user_names.sql.expected.formatted.sql
index 3bb7e90e5..d4a8b405c 100644
--- a/tests/clickhouse-reference/01119_weird_user_names.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01119_weird_user_names.sql.expected.formatted.sql
@@ -25,9 +25,9 @@ CREATE USER ` INTERSERVER SECRET `; -- { serverError BAD_ARGUMENTS }
 
 CREATE USER 'test 01119';
 
-alter user `test 01119` rename to " spaces ";
+ALTER USER `test 01119` RENAME TO ` spaces `;
 
-alter user " spaces " rename to " INTERSERVER SECRET "; -- { serverError BAD_ARGUMENTS }
+ALTER USER ` spaces ` RENAME TO ` INTERSERVER SECRET `; -- { serverError BAD_ARGUMENTS }
 
 CREATE USER `Вася Пупкин`;
 
diff --git a/tests/clickhouse-reference/01125_dict_ddl_cannot_add_column.sql.expected.ast.json b/tests/clickhouse-reference/01125_dict_ddl_cannot_add_column.sql.expected.ast.json
index b7c6f4ce2..17c12e4a4 100644
--- a/tests/clickhouse-reference/01125_dict_ddl_cannot_add_column.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01125_dict_ddl_cannot_add_column.sql.expected.ast.json
@@ -196,7 +196,10 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES"
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/01152_cross_replication.sql.expected.ast.json b/tests/clickhouse-reference/01152_cross_replication.sql.expected.ast.json
index ad86db7b9..79e4a8a72 100644
--- a/tests/clickhouse-reference/01152_cross_replication.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01152_cross_replication.sql.expected.ast.json
@@ -286,12 +286,20 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM shard_0"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": "shard_0"
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM shard_1"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": "shard_1"
+    }
   },
   {
     "kind": "showCreate",
diff --git a/tests/clickhouse-reference/01155_rename_move_materialized_view.sql.expected.ast.json b/tests/clickhouse-reference/01155_rename_move_materialized_view.sql.expected.ast.json
index 6624c700b..fd32665af 100644
--- a/tests/clickhouse-reference/01155_rename_move_materialized_view.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01155_rename_move_materialized_view.sql.expected.ast.json
@@ -762,8 +762,12 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM test_01155_ordinary"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": "test_01155_ordinary"
+    }
   },
   {
     "kind": "rename",
@@ -1653,7 +1657,11 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM test_01155_atomic"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": "test_01155_atomic"
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/01161_information_schema.sql.expected.ast.json b/tests/clickhouse-reference/01161_information_schema.sql.expected.ast.json
index 7b756caba..cbff92ab9 100644
--- a/tests/clickhouse-reference/01161_information_schema.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01161_information_schema.sql.expected.ast.json
@@ -1,7 +1,11 @@
 [
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM information_schema",
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": "information_schema"
+    },
     "leadingComments": [
       "-- Tags: memory-engine",
       "-- Uppercase/lowercase are okay, mixed case isn't"
diff --git a/tests/clickhouse-reference/01172_transaction_counters.sql.expected.ast.json b/tests/clickhouse-reference/01172_transaction_counters.sql.expected.ast.json
index 57272aeaa..190f6d82b 100644
--- a/tests/clickhouse-reference/01172_transaction_counters.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01172_transaction_counters.sql.expected.ast.json
@@ -110,8 +110,8 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "begin transaction"
+    "kind": "transactionControl",
+    "action": "begin"
   },
   {
     "kind": "insert",
@@ -343,8 +343,8 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "rollback"
+    "kind": "transactionControl",
+    "action": "rollback"
   },
   {
     "kind": "insert",
@@ -611,8 +611,8 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "commit"
+    "kind": "transactionControl",
+    "action": "commit"
   },
   {
     "kind": "detach",
diff --git a/tests/clickhouse-reference/01172_transaction_counters.sql.expected.formatted.sql b/tests/clickhouse-reference/01172_transaction_counters.sql.expected.formatted.sql
index 68fd86468..f64744672 100644
--- a/tests/clickhouse-reference/01172_transaction_counters.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01172_transaction_counters.sql.expected.formatted.sql
@@ -19,7 +19,7 @@ SYSTEM stop merges txn_counters;
 
 SET throw_on_unsupported_query_inside_transaction = 0;
 
-begin transaction;
+BEGIN TRANSACTION;
 
 INSERT INTO txn_counters (n);
 
@@ -46,7 +46,7 @@ WHERE database = currentDatabase()
     AND table = 'txn_counters'
 ORDER BY `system`.parts.name ASC;
 
-rollback;
+ROLLBACK;
 
 INSERT INTO txn_counters (n);
 
@@ -77,7 +77,7 @@ SELECT
     5,
     transactionID().3 == serverUUID();
 
-commit;
+COMMIT;
 
 DETACH TABLE txn_counters;
 
diff --git a/tests/clickhouse-reference/01173_transaction_control_queries.sql.expected.ast.json b/tests/clickhouse-reference/01173_transaction_control_queries.sql.expected.ast.json
index 8cf311398..62c077dbb 100644
--- a/tests/clickhouse-reference/01173_transaction_control_queries.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01173_transaction_control_queries.sql.expected.ast.json
@@ -79,22 +79,22 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "commit",
+    "kind": "transactionControl",
+    "action": "commit",
     "trailingComments": [
       "-- { serverError INVALID_TRANSACTION } -- no transaction"
     ]
   },
   {
-    "kind": "system",
-    "body": "rollback",
+    "kind": "transactionControl",
+    "action": "rollback",
     "trailingComments": [
       "-- { serverError INVALID_TRANSACTION }"
     ]
   },
   {
-    "kind": "system",
-    "body": "begin transaction"
+    "kind": "transactionControl",
+    "action": "begin"
   },
   {
     "kind": "insert",
@@ -788,6 +788,7 @@
   },
   {
     "kind": "transactionControl",
+    "action": "snapshot",
     "snapshot": "1"
   },
   {
@@ -823,6 +824,7 @@
   },
   {
     "kind": "transactionControl",
+    "action": "snapshot",
     "snapshot": "3"
   },
   {
@@ -952,6 +954,7 @@
   },
   {
     "kind": "transactionControl",
+    "action": "snapshot",
     "snapshot": "1000000000000000"
   },
   {
@@ -987,6 +990,7 @@
   },
   {
     "kind": "transactionControl",
+    "action": "snapshot",
     "snapshot": "5",
     "trailingComments": [
       "-- { serverError INVALID_TRANSACTION }"
diff --git a/tests/clickhouse-reference/01173_transaction_control_queries.sql.expected.formatted.sql b/tests/clickhouse-reference/01173_transaction_control_queries.sql.expected.formatted.sql
index 7744b2ea2..8c81945bf 100644
--- a/tests/clickhouse-reference/01173_transaction_control_queries.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01173_transaction_control_queries.sql.expected.formatted.sql
@@ -17,11 +17,11 @@ CREATE TABLE mt2
 ENGINE = MergeTree
 ORDER BY n;
 
-commit; -- { serverError INVALID_TRANSACTION } -- no transaction
+COMMIT; -- { serverError INVALID_TRANSACTION } -- no transaction
 
-rollback; -- { serverError INVALID_TRANSACTION }
+ROLLBACK; -- { serverError INVALID_TRANSACTION }
 
-begin transaction;
+BEGIN TRANSACTION;
 
 INSERT INTO mt1;
 
diff --git a/tests/clickhouse-reference/01185_create_or_replace_table.sql.expected.ast.json b/tests/clickhouse-reference/01185_create_or_replace_table.sql.expected.ast.json
index bb300d555..e1f7ff538 100644
--- a/tests/clickhouse-reference/01185_create_or_replace_table.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01185_create_or_replace_table.sql.expected.ast.json
@@ -52,8 +52,11 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "show tables"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES"
+    }
   },
   {
     "kind": "createTable",
diff --git a/tests/clickhouse-reference/01185_create_or_replace_table.sql.expected.formatted.sql b/tests/clickhouse-reference/01185_create_or_replace_table.sql.expected.formatted.sql
index 2863f1d98..f927d5765 100644
--- a/tests/clickhouse-reference/01185_create_or_replace_table.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01185_create_or_replace_table.sql.expected.formatted.sql
@@ -9,7 +9,7 @@ REPLACE TABLE t1
 ENGINE = MergeTree
 ORDER BY n; -- { serverError UNKNOWN_TABLE }
 
-show tables;
+SHOW TABLES;
 
 CREATE OR REPLACE TABLE t1
 (
diff --git a/tests/clickhouse-reference/01271_show_privileges.sql.expected.ast.json b/tests/clickhouse-reference/01271_show_privileges.sql.expected.ast.json
index 03851abf6..d2ebda29d 100644
--- a/tests/clickhouse-reference/01271_show_privileges.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01271_show_privileges.sql.expected.ast.json
@@ -1,6 +1,8 @@
 [
   {
-    "kind": "system",
-    "body": "SHOW PRIVILEGES"
+    "kind": "show",
+    "show": {
+      "type": "privileges"
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/01292_create_user.sql.expected.ast.json b/tests/clickhouse-reference/01292_create_user.sql.expected.ast.json
index 2f283bac9..8de6de77e 100644
--- a/tests/clickhouse-reference/01292_create_user.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01292_create_user.sql.expected.ast.json
@@ -45,8 +45,16 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u1_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u1_01292"
+        }
+      ]
+    }
   },
   {
     "kind": "createUser",
@@ -89,20 +97,56 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u2_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u2_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u3_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u3_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u2_01292 RENAME TO 'u2_01292_renamed'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u2_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "rename",
+        "to": {
+          "name": "'u2_01292_renamed'"
+        }
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u2_01292_renamed"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u2_01292_renamed"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
@@ -224,48 +268,161 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u4_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u4_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u5_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u5_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u6_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u6_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u7_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u7_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u8_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u8_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u9_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u9_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u1_01292 IDENTIFIED BY '123qwe'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u1_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "identified",
+        "auth": [
+          {
+            "secret": "123qwe"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u2_01292 IDENTIFIED BY '123qwe'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u2_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "identified",
+        "auth": [
+          {
+            "secret": "123qwe"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u3_01292 IDENTIFIED BY '123qwe'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u3_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "identified",
+        "auth": [
+          {
+            "secret": "123qwe"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u4_01292 IDENTIFIED WITH plaintext_password BY '123qwe'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u4_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "identified",
+        "auth": [
+          {
+            "secret": "123qwe"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u5_01292 NOT IDENTIFIED"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u5_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "notIdentified"
+      }
+    ]
   },
   {
     "kind": "system",
@@ -507,48 +664,165 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u10_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u10_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u11_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u11_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u12_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u12_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u13_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u13_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u14_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u14_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u15_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u15_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u16_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u16_01292"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u1_01292 HOST NONE"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u1_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "none"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u2_01292 HOST NAME 'myhost.com'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u2_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "name",
+            "value": "myhost.com"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u3_01292 ADD HOST NAME 'myhost.com'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u3_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "mode": "ADD",
+        "hosts": [
+          {
+            "kind": "name",
+            "value": "myhost.com"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u4_01292 DROP HOST NAME 'myhost.com'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u4_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "mode": "DROP",
+        "hosts": [
+          {
+            "kind": "name",
+            "value": "myhost.com"
+          }
+        ]
+      }
+    ]
   },
   {
     "kind": "system",
@@ -600,48 +874,155 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u1_01292@'%'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u1_01292",
+          "host": "'%'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u2_01292@'%.myhost.com'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u2_01292",
+          "host": "'%.myhost.com'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER 'u2_01292@%.myhost.com'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "'u2_01292@%.myhost.com'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u3_01292@'192.168.%.%'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u3_01292",
+          "host": "'192.168.%.%'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER 'u3_01292@192.168.%.%'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "'u3_01292@192.168.%.%'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u4_01292@'::1'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u4_01292",
+          "host": "'::1'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER 'u4_01292@::1'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "'u4_01292@::1'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u5_01292@'65:ff0c::/96'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u5_01292",
+          "host": "'65:ff0c::/96'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER 'u5_01292@65:ff0c::/96'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "'u5_01292@65:ff0c::/96'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u1_01292@'%' HOST LOCAL"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u1_01292",
+        "host": "'%'"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "local"
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u2_01292@'%.myhost.com' HOST ANY"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u2_01292",
+        "host": "'%.myhost.com'"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "any"
+          }
+        ]
+      }
+    ]
   },
   {
     "kind": "system",
@@ -812,16 +1193,66 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u1_01292 SETTINGS readonly=1"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u1_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "settings",
+        "settings": [
+          {
+            "kind": "setting",
+            "name": "readonly",
+            "value": {
+              "kind": "literal",
+              "type": "UInt64",
+              "value": "1"
+            }
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u2_01292 SETTINGS readonly=1"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u2_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "settings",
+        "settings": [
+          {
+            "kind": "setting",
+            "name": "readonly",
+            "value": {
+              "kind": "literal",
+              "type": "UInt64",
+              "value": "1"
+            }
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u3_01292 SETTINGS NONE"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u3_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "settings",
+        "settings": "NONE"
+      }
+    ]
   },
   {
     "kind": "createRole",
@@ -915,16 +1346,58 @@
     }
   },
   {
-    "kind": "system",
-    "body": "GRANT r1_01292, r2_01292 TO u1_01292, u2_01292, u3_01292, u4_01292, u5_01292, u6_01292"
+    "kind": "grant",
+    "operation": "GRANT",
+    "roles": [
+      "r1_01292",
+      "r2_01292"
+    ],
+    "grantees": [
+      "u1_01292",
+      "u2_01292",
+      "u3_01292",
+      "u4_01292",
+      "u5_01292",
+      "u6_01292"
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u1_01292 DEFAULT ROLE r1_01292"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u1_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "defaultRole",
+        "roles": {
+          "kind": "names",
+          "names": [
+            "r1_01292"
+          ]
+        }
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u2_01292 DEFAULT ROLE ALL EXCEPT r2_01292"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u2_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "defaultRole",
+        "roles": {
+          "kind": "all",
+          "except": [
+            "r2_01292"
+          ]
+        }
+      }
+    ]
   },
   {
     "kind": "setRole",
@@ -1002,20 +1475,64 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u1_01292 NOT IDENTIFIED HOST LIKE '%.%.myhost.com' DEFAULT ROLE NONE SETTINGS PROFILE 'default'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u1_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "notIdentified"
+      },
+      {
+        "kind": "host",
+        "hosts": [
+          {
+            "kind": "like",
+            "value": "%.%.myhost.com"
+          }
+        ]
+      },
+      {
+        "kind": "defaultRole",
+        "roles": {
+          "kind": "none"
+        }
+      },
+      {
+        "kind": "settings",
+        "settings": [
+          {
+            "kind": "profile",
+            "name": "'default'"
+          }
+        ]
+      }
+    ]
   },
   {
     "kind": "system",
     "body": "DROP USER u1_01292"
   },
   {
-    "kind": "system",
-    "body": "GRANT r1_01292 TO u1_01292"
+    "kind": "grant",
+    "operation": "GRANT",
+    "roles": [
+      "r1_01292"
+    ],
+    "grantees": [
+      "u1_01292"
+    ]
   },
   {
-    "kind": "system",
-    "body": "SHOW GRANTS FOR u1_01292"
+    "kind": "show",
+    "show": {
+      "type": "grants",
+      "for": [
+        "u1_01292"
+      ]
+    }
   },
   {
     "kind": "createUser",
@@ -1027,8 +1544,14 @@
     "ifNotExists": true
   },
   {
-    "kind": "system",
-    "body": "GRANT r2_01292 TO u1_01292"
+    "kind": "grant",
+    "operation": "GRANT",
+    "roles": [
+      "r2_01292"
+    ],
+    "grantees": [
+      "u1_01292"
+    ]
   },
   {
     "kind": "createUser",
@@ -1110,20 +1633,90 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u1_01292, u2_01292, u3_01292, u4_01292, u5_01292@'%.host.com', u6_01292@'%.host.com'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u1_01292"
+        },
+        {
+          "name": "u2_01292"
+        },
+        {
+          "name": "u3_01292"
+        },
+        {
+          "name": "u4_01292"
+        },
+        {
+          "name": "u5_01292",
+          "host": "'%.host.com'"
+        },
+        {
+          "name": "u6_01292",
+          "host": "'%.host.com'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u7_01292@'%.host.com', u8_01292@'%.otherhost.com'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u7_01292",
+          "host": "'%.host.com'"
+        },
+        {
+          "name": "u8_01292",
+          "host": "'%.otherhost.com'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER USER u1_01292, u2_01292 SETTINGS readonly=1"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "u1_01292"
+      },
+      {
+        "name": "u2_01292"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "settings",
+        "settings": [
+          {
+            "kind": "setting",
+            "name": "readonly",
+            "value": {
+              "kind": "literal",
+              "type": "UInt64",
+              "value": "1"
+            }
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT r1_01292, r2_01292 TO u2_01292, u3_01292, u4_01292"
+    "kind": "grant",
+    "operation": "GRANT",
+    "roles": [
+      "r1_01292",
+      "r2_01292"
+    ],
+    "grantees": [
+      "u2_01292",
+      "u3_01292",
+      "u4_01292"
+    ]
   },
   {
     "kind": "setRole",
@@ -1141,8 +1734,25 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u1_01292, u2_01292, u3_01292, u4_01292"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u1_01292"
+        },
+        {
+          "name": "u2_01292"
+        },
+        {
+          "name": "u3_01292"
+        },
+        {
+          "name": "u4_01292"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
@@ -1798,12 +2408,30 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u1_01292@'192.168.%.%'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u1_01292",
+          "host": "'192.168.%.%'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u2_01292@'192.168.%.%'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u2_01292",
+          "host": "'192.168.%.%'"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/01292_create_user.sql.expected.formatted.sql b/tests/clickhouse-reference/01292_create_user.sql.expected.formatted.sql
index f9386388b..2365567e1 100644
--- a/tests/clickhouse-reference/01292_create_user.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01292_create_user.sql.expected.formatted.sql
@@ -67,7 +67,7 @@ ALTER USER u2_01292 IDENTIFIED BY '123qwe';
 
 ALTER USER u3_01292 IDENTIFIED BY '123qwe';
 
-ALTER USER u4_01292 IDENTIFIED WITH plaintext_password BY '123qwe';
+ALTER USER u4_01292 IDENTIFIED BY '123qwe';
 
 ALTER USER u5_01292 NOT IDENTIFIED;
 
diff --git a/tests/clickhouse-reference/01293_create_role.sql.expected.ast.json b/tests/clickhouse-reference/01293_create_role.sql.expected.ast.json
index 4afd66015..d7b58866a 100644
--- a/tests/clickhouse-reference/01293_create_role.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01293_create_role.sql.expected.ast.json
@@ -33,8 +33,16 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r1_01293"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r1_01293"
+        }
+      ]
+    }
   },
   {
     "kind": "createRole",
@@ -46,16 +54,39 @@
     "settings": "NONE"
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r2_01293"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r2_01293"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER ROLE r2_01293 RENAME TO 'r2_01293_renamed'"
+    "kind": "alterRole",
+    "names": [
+      {
+        "name": "r2_01293"
+      }
+    ],
+    "renameTo": {
+      "name": "'r2_01293_renamed'"
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r2_01293_renamed"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r2_01293_renamed"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
@@ -80,16 +111,42 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r1_01293@'%'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r1_01293",
+          "host": "'%'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r2_01293@'%.myhost.com'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r2_01293",
+          "host": "'%.myhost.com'"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE 'r2_01293@%.myhost.com'"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "'r2_01293@%.myhost.com'"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
@@ -260,44 +317,135 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r3_01293"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r3_01293"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r4_01293"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r4_01293"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r5_01293"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r5_01293"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r6_01293"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r6_01293"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r7_01293"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r7_01293"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r8_01293"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r8_01293"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r9_01293"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r9_01293"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER ROLE r1_01293 SETTINGS readonly=1"
+    "kind": "alterRole",
+    "names": [
+      {
+        "name": "r1_01293"
+      }
+    ],
+    "settings": [
+      {
+        "kind": "setting",
+        "name": "readonly",
+        "value": {
+          "kind": "literal",
+          "type": "UInt64",
+          "value": "1"
+        }
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER ROLE r2_01293 SETTINGS readonly=1"
+    "kind": "alterRole",
+    "names": [
+      {
+        "name": "r2_01293"
+      }
+    ],
+    "settings": [
+      {
+        "kind": "setting",
+        "name": "readonly",
+        "value": {
+          "kind": "literal",
+          "type": "UInt64",
+          "value": "1"
+        }
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER ROLE r3_01293 SETTINGS NONE"
+    "kind": "alterRole",
+    "names": [
+      {
+        "name": "r3_01293"
+      }
+    ],
+    "settings": "NONE"
   },
   {
     "kind": "system",
@@ -315,12 +463,41 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE r1_01293, r2_01293"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "r1_01293"
+        },
+        {
+          "name": "r2_01293"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER ROLE r1_01293, r2_01293 SETTINGS readonly=1"
+    "kind": "alterRole",
+    "names": [
+      {
+        "name": "r1_01293"
+      },
+      {
+        "name": "r2_01293"
+      }
+    ],
+    "settings": [
+      {
+        "kind": "setting",
+        "name": "readonly",
+        "value": {
+          "kind": "literal",
+          "type": "UInt64",
+          "value": "1"
+        }
+      }
+    ]
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/01293_show_settings.sql.expected.ast.json b/tests/clickhouse-reference/01293_show_settings.sql.expected.ast.json
index 761d25551..51e17d64c 100644
--- a/tests/clickhouse-reference/01293_show_settings.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01293_show_settings.sql.expected.ast.json
@@ -1,17 +1,38 @@
 [
   {
-    "kind": "system",
-    "body": "show settings like 'send_timeout'",
+    "kind": "show",
+    "show": {
+      "type": "accessEntities",
+      "objectType": "SETTINGS",
+      "like": {
+        "pattern": "send_timeout"
+      }
+    },
     "leadingComments": [
       "-- Tags: no-random-settings"
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW SETTINGS ILIKE '%CONNECT_timeout%'"
+    "kind": "show",
+    "show": {
+      "type": "accessEntities",
+      "objectType": "SETTINGS",
+      "like": {
+        "pattern": "%CONNECT_timeout%",
+        "ilike": true
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CHANGED SETTINGS ILIKE '%MEMORY%'"
+    "kind": "show",
+    "show": {
+      "type": "accessEntities",
+      "objectType": "SETTINGS",
+      "modifier": "CHANGED",
+      "like": {
+        "pattern": "%MEMORY%",
+        "ilike": true
+      }
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/01293_show_settings.sql.expected.formatted.sql b/tests/clickhouse-reference/01293_show_settings.sql.expected.formatted.sql
index e50452b1d..ce9f3f43c 100644
--- a/tests/clickhouse-reference/01293_show_settings.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01293_show_settings.sql.expected.formatted.sql
@@ -1,5 +1,5 @@
 -- Tags: no-random-settings
-show settings like 'send_timeout';
+SHOW SETTINGS LIKE 'send_timeout';
 
 SHOW SETTINGS ILIKE '%CONNECT_timeout%';
 
diff --git a/tests/clickhouse-reference/01294_create_settings_profile.sql.expected.ast.json b/tests/clickhouse-reference/01294_create_settings_profile.sql.expected.ast.json
index 1ee960ce5..5b12f37fd 100644
--- a/tests/clickhouse-reference/01294_create_settings_profile.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01294_create_settings_profile.sql.expected.ast.json
@@ -36,8 +36,16 @@
     "hasSettingsKeyword": true
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE SETTINGS PROFILE s1_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s1_01294"
+        }
+      ]
+    }
   },
   {
     "kind": "createSettingsProfile",
@@ -57,27 +65,63 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE PROFILE s2_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s2_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE SETTINGS PROFILE s3_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s3_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER SETTINGS PROFILE s2_01294 RENAME TO 's2_01294_renamed'"
+    "kind": "alterSettingsProfile",
+    "names": [
+      "s2_01294"
+    ],
+    "hasSettingsKeyword": true,
+    "renameTo": "'s2_01294_renamed'"
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE SETTINGS PROFILE s2_01294",
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s2_01294"
+        }
+      ]
+    },
     "trailingComments": [
       "-- { serverError THERE_IS_NO_PROFILE } -- Profile not found"
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE SETTINGS PROFILE s2_01294_renamed"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s2_01294_renamed"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
@@ -268,52 +312,153 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE PROFILE s1_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s1_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE PROFILE s3_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s3_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE PROFILE s4_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s4_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE PROFILE s5_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s5_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE PROFILE s6_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s6_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE PROFILE s7_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s7_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE PROFILE s8_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s8_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE PROFILE s9_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s9_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE PROFILE s10_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s10_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER PROFILE s1_01294 SETTINGS readonly=0"
+    "kind": "alterSettingsProfile",
+    "names": [
+      "s1_01294"
+    ],
+    "settings": [
+      {
+        "kind": "setting",
+        "name": "readonly",
+        "value": {
+          "kind": "literal",
+          "type": "UInt64",
+          "value": "0"
+        }
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER PROFILE s2_01294 SETTINGS readonly=1"
+    "kind": "alterSettingsProfile",
+    "names": [
+      "s2_01294"
+    ],
+    "settings": [
+      {
+        "kind": "setting",
+        "name": "readonly",
+        "value": {
+          "kind": "literal",
+          "type": "UInt64",
+          "value": "1"
+        }
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER PROFILE s3_01294 SETTINGS NONE"
+    "kind": "alterSettingsProfile",
+    "names": [
+      "s3_01294"
+    ],
+    "settings": "NONE"
   },
   {
     "kind": "system",
@@ -416,12 +561,25 @@
     }
   },
   {
-    "kind": "system",
-    "body": "ALTER PROFILE s1_01294 TO u1_01294"
+    "kind": "alterSettingsProfile",
+    "names": [
+      "s1_01294"
+    ],
+    "to": {
+      "kind": "names",
+      "names": [
+        "u1_01294"
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER PROFILE s2_01294 TO NONE"
+    "kind": "alterSettingsProfile",
+    "names": [
+      "s2_01294"
+    ],
+    "to": {
+      "kind": "none"
+    }
   },
   {
     "kind": "system",
@@ -452,8 +610,20 @@
     }
   },
   {
-    "kind": "system",
-    "body": "ALTER SETTINGS PROFILE s1_01294 SETTINGS INHERIT 'default' TO NONE"
+    "kind": "alterSettingsProfile",
+    "names": [
+      "s1_01294"
+    ],
+    "hasSettingsKeyword": true,
+    "settings": [
+      {
+        "kind": "inherit",
+        "name": "'default'"
+      }
+    ],
+    "to": {
+      "kind": "none"
+    }
   },
   {
     "kind": "system",
@@ -488,16 +658,57 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE PROFILE s1_01294, s2_01294, s3_01294, s4_01294"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s1_01294"
+        },
+        {
+          "name": "s2_01294"
+        },
+        {
+          "name": "s3_01294"
+        },
+        {
+          "name": "s4_01294"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER PROFILE s1_01294, s2_01294 SETTINGS max_memory_usage=6000000"
+    "kind": "alterSettingsProfile",
+    "names": [
+      "s1_01294",
+      "s2_01294"
+    ],
+    "settings": [
+      {
+        "kind": "setting",
+        "name": "max_memory_usage",
+        "value": {
+          "kind": "literal",
+          "type": "UInt64",
+          "value": "6000000"
+        }
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER PROFILE s2_01294, s3_01294, s4_01294 TO r1_01294"
+    "kind": "alterSettingsProfile",
+    "names": [
+      "s2_01294",
+      "s3_01294",
+      "s4_01294"
+    ],
+    "to": {
+      "kind": "names",
+      "names": [
+        "r1_01294"
+      ]
+    }
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/01294_create_settings_profile.sql.expected.formatted.sql b/tests/clickhouse-reference/01294_create_settings_profile.sql.expected.formatted.sql
index 2379c962c..e47c769bb 100644
--- a/tests/clickhouse-reference/01294_create_settings_profile.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01294_create_settings_profile.sql.expected.formatted.sql
@@ -17,7 +17,7 @@ CREATE SETTINGS PROFILE s2_01294 SETTINGS NONE TO NONE;
 
 CREATE PROFILE s3_01294;
 
-SHOW CREATE PROFILE s2_01294;
+SHOW CREATE SETTINGS PROFILE s2_01294;
 
 SHOW CREATE SETTINGS PROFILE s3_01294;
 
@@ -49,23 +49,23 @@ CREATE PROFILE s9_01294 SETTINGS INHERIT 'default', max_memory_usage=5000000 WRI
 
 CREATE PROFILE s10_01294 SETTINGS INHERIT s1_01294, s3_01294, INHERIT default, readonly=0, max_memory_usage MAX 6000000;
 
-SHOW CREATE PROFILE s1_01294;
+SHOW CREATE SETTINGS PROFILE s1_01294;
 
-SHOW CREATE PROFILE s3_01294;
+SHOW CREATE SETTINGS PROFILE s3_01294;
 
-SHOW CREATE PROFILE s4_01294;
+SHOW CREATE SETTINGS PROFILE s4_01294;
 
-SHOW CREATE PROFILE s5_01294;
+SHOW CREATE SETTINGS PROFILE s5_01294;
 
-SHOW CREATE PROFILE s6_01294;
+SHOW CREATE SETTINGS PROFILE s6_01294;
 
-SHOW CREATE PROFILE s7_01294;
+SHOW CREATE SETTINGS PROFILE s7_01294;
 
-SHOW CREATE PROFILE s8_01294;
+SHOW CREATE SETTINGS PROFILE s8_01294;
 
-SHOW CREATE PROFILE s9_01294;
+SHOW CREATE SETTINGS PROFILE s9_01294;
 
-SHOW CREATE PROFILE s10_01294;
+SHOW CREATE SETTINGS PROFILE s10_01294;
 
 ALTER PROFILE s1_01294 SETTINGS readonly=0;
 
@@ -109,7 +109,7 @@ CREATE PROFILE s1_01294, s2_01294 SETTINGS max_memory_usage=5000000;
 
 CREATE PROFILE s3_01294, s4_01294 TO ALL;
 
-SHOW CREATE PROFILE s1_01294, s2_01294, s3_01294, s4_01294;
+SHOW CREATE SETTINGS PROFILE s1_01294, s2_01294, s3_01294, s4_01294;
 
 ALTER PROFILE s1_01294, s2_01294 SETTINGS max_memory_usage=6000000;
 
diff --git a/tests/clickhouse-reference/01295_create_row_policy.sql.expected.ast.json b/tests/clickhouse-reference/01295_create_row_policy.sql.expected.ast.json
index bb7f88ac7..61232d8b4 100644
--- a/tests/clickhouse-reference/01295_create_row_policy.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01295_create_row_policy.sql.expected.ast.json
@@ -53,8 +53,22 @@
     "hasRowKeyword": true
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROW POLICY p1_01295 ON db.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p1_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
     "kind": "createRowPolicy",
@@ -97,27 +111,96 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p2_01295 ON db.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p2_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROW POLICY p3_01295 ON db.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p3_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER ROW POLICY p2_01295 ON db.table RENAME TO 'p2_01295_renamed'"
+    "kind": "alterRowPolicy",
+    "targets": [
+      {
+        "names": [
+          "p2_01295"
+        ],
+        "table": {
+          "kind": "tableRef",
+          "database": "db",
+          "table": "table"
+        }
+      }
+    ],
+    "hasRowKeyword": true,
+    "renameTo": "'p2_01295_renamed'"
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROW POLICY p2_01295 ON db.table",
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p2_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    },
     "trailingComments": [
       "-- { serverError UNKNOWN_ROW_POLICY } -- Policy not found"
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROW POLICY p2_01295_renamed ON db.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p2_01295_renamed"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
     "kind": "system",
@@ -238,16 +321,66 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p1_01295 ON db.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p1_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p3_01295 ON db.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p3_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER ROW POLICY p1_01295 ON db.table FOR SELECT USING 0 AS RESTRICTIVE"
+    "kind": "alterRowPolicy",
+    "targets": [
+      {
+        "names": [
+          "p1_01295"
+        ],
+        "table": {
+          "kind": "tableRef",
+          "database": "db",
+          "table": "table"
+        }
+      }
+    ],
+    "hasRowKeyword": true,
+    "forSelect": true,
+    "using": {
+      "kind": "alias",
+      "expr": {
+        "kind": "literal",
+        "type": "UInt64",
+        "value": "0"
+      },
+      "alias": "RESTRICTIVE"
+    }
   },
   {
     "kind": "system",
@@ -413,28 +546,115 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p4_01295 ON db.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p4_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p5_01295 ON db.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p5_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p6_01295 ON db.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p6_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p7_01295 ON db.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p7_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER POLICY p1_01295 ON db.table TO u1_01295"
+    "kind": "alterRowPolicy",
+    "targets": [
+      {
+        "names": [
+          "p1_01295"
+        ],
+        "table": {
+          "kind": "tableRef",
+          "database": "db",
+          "table": "table"
+        }
+      }
+    ],
+    "to": {
+      "kind": "names",
+      "names": [
+        "u1_01295"
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER POLICY p2_01295 ON db.table TO NONE"
+    "kind": "alterRowPolicy",
+    "targets": [
+      {
+        "names": [
+          "p2_01295"
+        ],
+        "table": {
+          "kind": "tableRef",
+          "database": "db",
+          "table": "table"
+        }
+      }
+    ],
+    "to": {
+      "kind": "none"
+    }
   },
   {
     "kind": "system",
@@ -537,20 +757,98 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p1_01295, p2_01295 ON db.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p1_01295",
+            "p2_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p3_01295 ON db.table, db2.table2"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p3_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        },
+        {
+          "names": [
+            "p3_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db2",
+            "table": "table2"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p4_01295 ON db.table, p5_01295 ON db2.table2"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p4_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db",
+            "table": "table"
+          }
+        },
+        {
+          "names": [
+            "p5_01295"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db2",
+            "table": "table2"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER POLICY p1_01295, p2_01295 ON db.table TO ALL"
+    "kind": "alterRowPolicy",
+    "targets": [
+      {
+        "names": [
+          "p1_01295",
+          "p2_01295"
+        ],
+        "table": {
+          "kind": "tableRef",
+          "database": "db",
+          "table": "table"
+        }
+      }
+    ],
+    "to": {
+      "kind": "all"
+    }
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/01295_create_row_policy.sql.expected.formatted.sql b/tests/clickhouse-reference/01295_create_row_policy.sql.expected.formatted.sql
index b82d7863b..99f758073 100644
--- a/tests/clickhouse-reference/01295_create_row_policy.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01295_create_row_policy.sql.expected.formatted.sql
@@ -21,7 +21,7 @@ CREATE ROW POLICY p2_01295 ON db.table USING NONE TO NONE;
 
 CREATE POLICY p3_01295 ON db.table;
 
-SHOW CREATE POLICY p2_01295 ON db.table;
+SHOW CREATE ROW POLICY p2_01295 ON db.table;
 
 SHOW CREATE ROW POLICY p3_01295 ON db.table;
 
@@ -40,9 +40,9 @@ CREATE ROW POLICY p2_01295 ON db.table USING id = currentUser() AS RESTRICTIVE;
 
 CREATE ROW POLICY p3_01295 ON db.table USING 1 AS PERMISSIVE;
 
-SHOW CREATE POLICY p1_01295 ON db.table;
+SHOW CREATE ROW POLICY p1_01295 ON db.table;
 
-SHOW CREATE POLICY p3_01295 ON db.table;
+SHOW CREATE ROW POLICY p3_01295 ON db.table;
 
 ALTER ROW POLICY p1_01295 ON db.table FOR SELECT USING 0 AS RESTRICTIVE;
 
@@ -66,13 +66,13 @@ CREATE POLICY p6_01295 ON db.table TO ALL EXCEPT r1_01295;
 
 CREATE POLICY p7_01295 ON db.table TO ALL EXCEPT r1_01295, u1_01295;
 
-SHOW CREATE POLICY p4_01295 ON db.table;
+SHOW CREATE ROW POLICY p4_01295 ON db.table;
 
-SHOW CREATE POLICY p5_01295 ON db.table;
+SHOW CREATE ROW POLICY p5_01295 ON db.table;
 
-SHOW CREATE POLICY p6_01295 ON db.table;
+SHOW CREATE ROW POLICY p6_01295 ON db.table;
 
-SHOW CREATE POLICY p7_01295 ON db.table;
+SHOW CREATE ROW POLICY p7_01295 ON db.table;
 
 ALTER POLICY p1_01295 ON db.table TO u1_01295;
 
@@ -86,11 +86,11 @@ CREATE ROW POLICY p3_01295 ON db.table, p3_01295 ON db2.table2 TO u1_01295;
 
 CREATE ROW POLICY p4_01295 ON db.table, p5_01295 ON db2.table2 USING a = b;
 
-SHOW CREATE POLICY p1_01295, p2_01295 ON db.table;
+SHOW CREATE ROW POLICY p1_01295, p2_01295 ON db.table;
 
-SHOW CREATE POLICY p3_01295 ON db.table, db2.table2;
+SHOW CREATE ROW POLICY p3_01295 ON db.table, p3_01295 ON db2.table2;
 
-SHOW CREATE POLICY p4_01295 ON db.table, p5_01295 ON db2.table2;
+SHOW CREATE ROW POLICY p4_01295 ON db.table, p5_01295 ON db2.table2;
 
 ALTER POLICY p1_01295, p2_01295 ON db.table TO ALL;
 
diff --git a/tests/clickhouse-reference/01296_create_row_policy_in_current_database.sql.expected.ast.json b/tests/clickhouse-reference/01296_create_row_policy_in_current_database.sql.expected.ast.json
index 3ff618636..41a6ad6e5 100644
--- a/tests/clickhouse-reference/01296_create_row_policy_in_current_database.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01296_create_row_policy_in_current_database.sql.expected.ast.json
@@ -56,16 +56,58 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p1_01296 ON db_01296.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p1_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db_01296",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p1_01296 ON table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p1_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER POLICY p1_01296 ON table USING 1"
+    "kind": "alterRowPolicy",
+    "targets": [
+      {
+        "names": [
+          "p1_01296"
+        ],
+        "table": {
+          "kind": "tableRef",
+          "table": "table"
+        }
+      }
+    ],
+    "using": {
+      "kind": "literal",
+      "type": "UInt64",
+      "value": "1"
+    }
   },
   {
     "kind": "system",
@@ -178,48 +220,197 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p2_01296 ON table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p2_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p3_01296 ON table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p3_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p3_01296 ON table2"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p3_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "table": "table2"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p4_01296 ON table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p4_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p5_01296 ON table2"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p5_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "table": "table2"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p2_01296 ON db_01296.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p2_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db_01296",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p3_01296 ON db_01296.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p3_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db_01296",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p3_01296 ON db_01296.table2"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p3_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db_01296",
+            "table": "table2"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p4_01296 ON db_01296.table"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p4_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db_01296",
+            "table": "table"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY p5_01296 ON db_01296.table2"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "p5_01296"
+          ],
+          "table": {
+            "kind": "tableRef",
+            "database": "db_01296",
+            "table": "table2"
+          }
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER POLICY p1_01296, p2_01296 ON table TO ALL"
+    "kind": "alterRowPolicy",
+    "targets": [
+      {
+        "names": [
+          "p1_01296",
+          "p2_01296"
+        ],
+        "table": {
+          "kind": "tableRef",
+          "table": "table"
+        }
+      }
+    ],
+    "to": {
+      "kind": "all"
+    }
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/01296_create_row_policy_in_current_database.sql.expected.formatted.sql b/tests/clickhouse-reference/01296_create_row_policy_in_current_database.sql.expected.formatted.sql
index 325f7bd9a..20bb12a50 100644
--- a/tests/clickhouse-reference/01296_create_row_policy_in_current_database.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01296_create_row_policy_in_current_database.sql.expected.formatted.sql
@@ -15,9 +15,9 @@ SELECT '-- one policy';
 
 CREATE POLICY p1_01296 ON table;
 
-SHOW CREATE POLICY p1_01296 ON db_01296.table;
+SHOW CREATE ROW POLICY p1_01296 ON db_01296.table;
 
-SHOW CREATE POLICY p1_01296 ON table;
+SHOW CREATE ROW POLICY p1_01296 ON table;
 
 ALTER POLICY p1_01296 ON table USING 1;
 
@@ -33,25 +33,25 @@ CREATE ROW POLICY p3_01296 ON table, p3_01296 ON table2 TO u1_01296;
 
 CREATE ROW POLICY p4_01296 ON table, p5_01296 ON table2 USING a = b;
 
-SHOW CREATE POLICY p2_01296 ON table;
+SHOW CREATE ROW POLICY p2_01296 ON table;
 
-SHOW CREATE POLICY p3_01296 ON table;
+SHOW CREATE ROW POLICY p3_01296 ON table;
 
-SHOW CREATE POLICY p3_01296 ON table2;
+SHOW CREATE ROW POLICY p3_01296 ON table2;
 
-SHOW CREATE POLICY p4_01296 ON table;
+SHOW CREATE ROW POLICY p4_01296 ON table;
 
-SHOW CREATE POLICY p5_01296 ON table2;
+SHOW CREATE ROW POLICY p5_01296 ON table2;
 
-SHOW CREATE POLICY p2_01296 ON db_01296.table;
+SHOW CREATE ROW POLICY p2_01296 ON db_01296.table;
 
-SHOW CREATE POLICY p3_01296 ON db_01296.table;
+SHOW CREATE ROW POLICY p3_01296 ON db_01296.table;
 
-SHOW CREATE POLICY p3_01296 ON db_01296.table2;
+SHOW CREATE ROW POLICY p3_01296 ON db_01296.table2;
 
-SHOW CREATE POLICY p4_01296 ON db_01296.table;
+SHOW CREATE ROW POLICY p4_01296 ON db_01296.table;
 
-SHOW CREATE POLICY p5_01296 ON db_01296.table2;
+SHOW CREATE ROW POLICY p5_01296 ON db_01296.table2;
 
 ALTER POLICY p1_01296, p2_01296 ON table TO ALL;
 
diff --git a/tests/clickhouse-reference/01297_create_quota.sql.expected.ast.json b/tests/clickhouse-reference/01297_create_quota.sql.expected.ast.json
index b6ac4c6fa..b81e2f20a 100644
--- a/tests/clickhouse-reference/01297_create_quota.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01297_create_quota.sql.expected.ast.json
@@ -35,8 +35,16 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q1_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q1_01297"
+        }
+      ]
+    }
   },
   {
     "kind": "createQuota",
@@ -85,24 +93,59 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q2_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q2_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q3_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q3_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q4_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q4_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q2_01297 RENAME TO 'q2_01297_renamed'"
+    "kind": "alterQuota",
+    "names": [
+      "q2_01297"
+    ],
+    "renameTo": "'q2_01297_renamed'"
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q2_01297_renamed"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q2_01297_renamed"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
@@ -241,48 +284,132 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q5_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q5_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q6_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q6_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q7_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q7_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q8_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q8_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q9_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q9_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q10_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q10_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q11_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q11_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q12_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q12_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q1_01297 KEY BY user_name"
+    "kind": "alterQuota",
+    "names": [
+      "q1_01297"
+    ],
+    "keyed": {
+      "keys": [
+        "user_name"
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q2_01297 KEY BY client_key, user_name"
+    "kind": "alterQuota",
+    "names": [
+      "q2_01297"
+    ],
+    "keyed": {
+      "keys": [
+        "client_key",
+        "user_name"
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q3_01297 NOT KEYED"
+    "kind": "alterQuota",
+    "names": [
+      "q3_01297"
+    ],
+    "keyed": {
+      "notKeyed": true
+    }
   },
   {
     "kind": "system",
@@ -552,24 +679,111 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q1_01297 FOR INTERVAL 5 DAY NO LIMITS"
+    "kind": "alterQuota",
+    "names": [
+      "q1_01297"
+    ],
+    "intervals": [
+      {
+        "duration": "5",
+        "unit": "DAY",
+        "noLimits": true
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q2_01297 FOR INTERVAL 30 MINUTE TRACKING ONLY"
+    "kind": "alterQuota",
+    "names": [
+      "q2_01297"
+    ],
+    "intervals": [
+      {
+        "duration": "30",
+        "unit": "MINUTE",
+        "trackingOnly": true
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q3_01297 FOR INTERVAL 2 HOUR MAX errors = 10, FOR INTERVAL 1 HOUR MAX queries = 70"
+    "kind": "alterQuota",
+    "names": [
+      "q3_01297"
+    ],
+    "intervals": [
+      {
+        "duration": "2",
+        "unit": "HOUR",
+        "limits": [
+          {
+            "name": "ERRORS",
+            "value": {
+              "kind": "literal",
+              "type": "UInt64",
+              "value": "10"
+            }
+          }
+        ]
+      },
+      {
+        "duration": "1",
+        "unit": "HOUR",
+        "limits": [
+          {
+            "name": "QUERIES",
+            "value": {
+              "kind": "literal",
+              "type": "UInt64",
+              "value": "70"
+            }
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q4_01297 FOR RANDOMIZED INTERVAL 2000 SECOND errors MAX 5"
+    "kind": "alterQuota",
+    "names": [
+      "q4_01297"
+    ],
+    "intervals": [
+      {
+        "duration": "2000",
+        "unit": "SECOND",
+        "randomized": true,
+        "limits": [
+          {
+            "name": "ERRORS",
+            "value": {
+              "kind": "literal",
+              "type": "UInt64",
+              "value": "5"
+            }
+          }
+        ]
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q5_01297 FOR 1 YEAR MAX errors = 111"
+    "kind": "alterQuota",
+    "names": [
+      "q5_01297"
+    ],
+    "intervals": [
+      {
+        "duration": "1",
+        "unit": "YEAR",
+        "limits": [
+          {
+            "name": "ERRORS",
+            "value": {
+              "kind": "literal",
+              "type": "UInt64",
+              "value": "111"
+            }
+          }
+        ]
+      }
+    ]
   },
   {
     "kind": "system",
@@ -672,12 +886,25 @@
     }
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q1_01297 TO u1_01297"
+    "kind": "alterQuota",
+    "names": [
+      "q1_01297"
+    ],
+    "to": {
+      "kind": "names",
+      "names": [
+        "u1_01297"
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q2_01297 TO NONE"
+    "kind": "alterQuota",
+    "names": [
+      "q2_01297"
+    ],
+    "to": {
+      "kind": "none"
+    }
   },
   {
     "kind": "system",
@@ -707,12 +934,39 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q1_01297, q2_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q1_01297"
+        },
+        {
+          "name": "q2_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "ALTER QUOTA q1_01297, q2_01297 FOR 1 day TRACKING ONLY TO r1_01297"
+    "kind": "alterQuota",
+    "names": [
+      "q1_01297",
+      "q2_01297"
+    ],
+    "to": {
+      "kind": "names",
+      "names": [
+        "r1_01297"
+      ]
+    },
+    "intervals": [
+      {
+        "duration": "1",
+        "unit": "DAY",
+        "trackingOnly": true
+      }
+    ]
   },
   {
     "kind": "system",
@@ -1445,20 +1699,52 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q13_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q13_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q14_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q14_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q15_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q15_01297"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA q16_01297"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "q16_01297"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/01297_create_quota.sql.expected.formatted.sql b/tests/clickhouse-reference/01297_create_quota.sql.expected.formatted.sql
index 1607fffa2..92966a161 100644
--- a/tests/clickhouse-reference/01297_create_quota.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01297_create_quota.sql.expected.formatted.sql
@@ -72,9 +72,9 @@ SHOW CREATE QUOTA q11_01297;
 
 SHOW CREATE QUOTA q12_01297;
 
-ALTER QUOTA q1_01297 KEY BY user_name;
+ALTER QUOTA q1_01297 KEYED BY user_name;
 
-ALTER QUOTA q2_01297 KEY BY client_key, user_name;
+ALTER QUOTA q2_01297 KEYED BY client_key, user_name;
 
 ALTER QUOTA q3_01297 NOT KEYED;
 
@@ -96,15 +96,15 @@ CREATE QUOTA q7_01297 FOR 1 QUARTER MAX ERRORS = 11, MAX QUERIES = 100;
 
 CREATE QUOTA q8_01297 FOR 0.5 YEAR MAX ERRORS = 11, MAX QUERIES = 100 FOR 2 MONTH MAX RESULT_ROWS = 1002;
 
-ALTER QUOTA q1_01297 FOR INTERVAL 5 DAY NO LIMITS;
+ALTER QUOTA q1_01297 FOR 5 DAY NO LIMITS;
 
-ALTER QUOTA q2_01297 FOR INTERVAL 30 MINUTE TRACKING ONLY;
+ALTER QUOTA q2_01297 FOR 30 MINUTE TRACKING ONLY;
 
-ALTER QUOTA q3_01297 FOR INTERVAL 2 HOUR MAX errors = 10, FOR INTERVAL 1 HOUR MAX queries = 70;
+ALTER QUOTA q3_01297 FOR 2 HOUR MAX ERRORS = 10 FOR 1 HOUR MAX QUERIES = 70;
 
-ALTER QUOTA q4_01297 FOR RANDOMIZED INTERVAL 2000 SECOND errors MAX 5;
+ALTER QUOTA q4_01297 FOR RANDOMIZED 2000 SECOND MAX ERRORS = 5;
 
-ALTER QUOTA q5_01297 FOR 1 YEAR MAX errors = 111;
+ALTER QUOTA q5_01297 FOR 1 YEAR MAX ERRORS = 111;
 
 DROP QUOTA q1_01297, q2_01297, q3_01297, q4_01297, q5_01297, q6_01297, q7_01297, q8_01297;
 
@@ -136,7 +136,7 @@ CREATE QUOTA q1_01297, q2_01297 FOR 1 DAY MAX ERRORS = 5;
 
 SHOW CREATE QUOTA q1_01297, q2_01297;
 
-ALTER QUOTA q1_01297, q2_01297 FOR 1 day TRACKING ONLY TO r1_01297;
+ALTER QUOTA q1_01297, q2_01297 FOR 1 DAY TRACKING ONLY TO r1_01297;
 
 DROP QUOTA q1_01297, q2_01297;
 
diff --git a/tests/clickhouse-reference/01355_ilike.sql.expected.ast.json b/tests/clickhouse-reference/01355_ilike.sql.expected.ast.json
index 2edcc19bc..db394d413 100644
--- a/tests/clickhouse-reference/01355_ilike.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01355_ilike.sql.expected.ast.json
@@ -748,8 +748,16 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES NOT ILIKE '%'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "like": {
+        "pattern": "%",
+        "not": true,
+        "ilike": true
+      }
+    }
   },
   {
     "kind": "createTable",
@@ -790,11 +798,26 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES ILIKE 'tES%'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "like": {
+        "pattern": "tES%",
+        "ilike": true
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES NOT ILIKE 'TeS%'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "like": {
+        "pattern": "TeS%",
+        "not": true,
+        "ilike": true
+      }
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/01418_custom_settings.sql.expected.ast.json b/tests/clickhouse-reference/01418_custom_settings.sql.expected.ast.json
index 8e19cc3d3..b61c0871e 100644
--- a/tests/clickhouse-reference/01418_custom_settings.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01418_custom_settings.sql.expected.ast.json
@@ -741,8 +741,16 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE SETTINGS PROFILE s1_01418"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s1_01418"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
@@ -938,8 +946,16 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE SETTINGS PROFILE s2_01418"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "s2_01418"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/01470_show_databases_like.sql.expected.ast.json b/tests/clickhouse-reference/01470_show_databases_like.sql.expected.ast.json
index 4cec2225c..10261895f 100644
--- a/tests/clickhouse-reference/01470_show_databases_like.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01470_show_databases_like.sql.expected.ast.json
@@ -8,8 +8,14 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "show databases like '%01470'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "DATABASES",
+      "like": {
+        "pattern": "%01470"
+      }
+    }
   },
   {
     "kind": "drop",
diff --git a/tests/clickhouse-reference/01470_show_databases_like.sql.expected.formatted.sql b/tests/clickhouse-reference/01470_show_databases_like.sql.expected.formatted.sql
index 70c5f0f67..a65eb4c40 100644
--- a/tests/clickhouse-reference/01470_show_databases_like.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01470_show_databases_like.sql.expected.formatted.sql
@@ -1,6 +1,6 @@
 -- Tags: no-parallel
 CREATE DATABASE IF NOT EXISTS test_01470;
 
-show databases like '%01470';
+SHOW DATABASES LIKE '%01470';
 
 DROP DATABASE test_01470;
\ No newline at end of file
diff --git a/tests/clickhouse-reference/01517_drop_mv_with_inner_table.sql.expected.ast.json b/tests/clickhouse-reference/01517_drop_mv_with_inner_table.sql.expected.ast.json
index 77e0019d9..d2ff12772 100644
--- a/tests/clickhouse-reference/01517_drop_mv_with_inner_table.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01517_drop_mv_with_inner_table.sql.expected.ast.json
@@ -103,8 +103,12 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "show tables from db_01517_atomic"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": "db_01517_atomic"
+    }
   },
   {
     "kind": "drop",
@@ -184,8 +188,12 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "show tables from db_01517_atomic_sync"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": "db_01517_atomic_sync"
+    }
   },
   {
     "kind": "drop",
@@ -281,8 +289,12 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "show tables from db_01517_ordinary"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": "db_01517_ordinary"
+    }
   },
   {
     "kind": "drop",
diff --git a/tests/clickhouse-reference/01517_drop_mv_with_inner_table.sql.expected.formatted.sql b/tests/clickhouse-reference/01517_drop_mv_with_inner_table.sql.expected.formatted.sql
index 39c4d9580..1ec44c298 100644
--- a/tests/clickhouse-reference/01517_drop_mv_with_inner_table.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01517_drop_mv_with_inner_table.sql.expected.formatted.sql
@@ -27,7 +27,7 @@ DROP TABLE db_01517_atomic.mv;
 -- ensure that the inner had been removed after sync drop
 DROP TABLE db_01517_atomic.source;
 
-show tables from db_01517_atomic;
+SHOW TABLES FROM db_01517_atomic;
 
 --
 -- Atomic
@@ -52,7 +52,7 @@ FROM db_01517_atomic_sync.source;
 -- drops it and hangs with Atomic engine, due to recursive DROP
 DROP TABLE db_01517_atomic_sync.mv;
 
-show tables from db_01517_atomic_sync;
+SHOW TABLES FROM db_01517_atomic_sync;
 
 --
 -- Ordinary
@@ -80,7 +80,7 @@ FROM db_01517_ordinary.source;
 -- drops it and hangs with Atomic engine, due to recursive DROP
 DROP TABLE db_01517_ordinary.mv;
 
-show tables from db_01517_ordinary;
+SHOW TABLES FROM db_01517_ordinary;
 
 DROP TABLE db_01517_atomic_sync.source;
 
diff --git a/tests/clickhouse-reference/01605_drop_settings_profile_while_assigned.sql.expected.ast.json b/tests/clickhouse-reference/01605_drop_settings_profile_while_assigned.sql.expected.ast.json
index bee2893af..2b0a7b504 100644
--- a/tests/clickhouse-reference/01605_drop_settings_profile_while_assigned.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01605_drop_settings_profile_while_assigned.sql.expected.ast.json
@@ -17,8 +17,23 @@
     "hasSettingsKeyword": true
   },
   {
-    "kind": "system",
-    "body": "ALTER USER 'test_01605' SETTINGS PROFILE 'test_01605'"
+    "kind": "alterUser",
+    "names": [
+      {
+        "name": "'test_01605'"
+      }
+    ],
+    "clauses": [
+      {
+        "kind": "settings",
+        "settings": [
+          {
+            "kind": "profile",
+            "name": "'test_01605'"
+          }
+        ]
+      }
+    ]
   },
   {
     "kind": "select",
diff --git a/tests/clickhouse-reference/01702_system_query_log.sql.expected.ast.json b/tests/clickhouse-reference/01702_system_query_log.sql.expected.ast.json
index 565689591..1882033fe 100644
--- a/tests/clickhouse-reference/01702_system_query_log.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01702_system_query_log.sql.expected.ast.json
@@ -335,8 +335,14 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "GRANT sqllt_role TO sqllt_user"
+    "kind": "grant",
+    "operation": "GRANT",
+    "roles": [
+      "sqllt_role"
+    ],
+    "grantees": [
+      "sqllt_user"
+    ]
   },
   {
     "kind": "set",
@@ -634,64 +640,210 @@
     "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "SHOW DATABASES LIKE 'sqllt' FORMAT Null"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "DATABASES",
+      "like": {
+        "pattern": "sqllt"
+      }
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM sqllt FORMAT Null"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": "sqllt"
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "SHOW DICTIONARIES FROM sqllt FORMAT Null"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "DICTIONARIES",
+      "from": "sqllt"
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "SHOW GRANTS FORMAT Null"
+    "kind": "show",
+    "show": {
+      "type": "grants"
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "SHOW GRANTS FOR sqllt_user FORMAT Null"
+    "kind": "show",
+    "show": {
+      "type": "grants",
+      "for": [
+        "sqllt_user"
+      ]
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER sqllt_user FORMAT Null"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "sqllt_user"
+        }
+      ]
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROLE sqllt_role FORMAT Null"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "ROLE",
+      "names": [
+        {
+          "name": "sqllt_role"
+        }
+      ]
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE POLICY sqllt_policy FORMAT Null"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "sqllt_policy"
+          ]
+        }
+      ]
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE ROW POLICY sqllt_row_policy FORMAT Null"
+    "kind": "show",
+    "show": {
+      "type": "createRowPolicy",
+      "policies": [
+        {
+          "names": [
+            "sqllt_row_policy"
+          ]
+        }
+      ]
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE QUOTA sqllt_quota FORMAT Null"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "QUOTA",
+      "names": [
+        {
+          "name": "sqllt_quota"
+        }
+      ]
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE SETTINGS PROFILE sqllt_settings_profile FORMAT Null"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "sqllt_settings_profile"
+        }
+      ]
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON sqllt.table TO sqllt_user"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "sqllt",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "sqllt_user"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT DROP ON sqllt.view TO sqllt_user"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "DROP"
+          }
+        ],
+        "target": {
+          "database": "sqllt",
+          "table": "view"
+        }
+      }
+    ],
+    "grantees": [
+      "sqllt_user"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT ON sqllt.table FROM sqllt_user"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "sqllt",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "sqllt_user"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE DROP ON sqllt.view FROM sqllt_user"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "DROP"
+          }
+        ],
+        "target": {
+          "database": "sqllt",
+          "table": "view"
+        }
+      }
+    ],
+    "grantees": [
+      "sqllt_user"
+    ]
   },
   {
     "kind": "describe",
diff --git a/tests/clickhouse-reference/01702_system_query_log.sql.expected.formatted.sql b/tests/clickhouse-reference/01702_system_query_log.sql.expected.formatted.sql
index e40ba9136..209a693e9 100644
--- a/tests/clickhouse-reference/01702_system_query_log.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01702_system_query_log.sql.expected.formatted.sql
@@ -120,7 +120,7 @@ SHOW CREATE USER sqllt_user FORMAT Null;
 
 SHOW CREATE ROLE sqllt_role FORMAT Null;
 
-SHOW CREATE POLICY sqllt_policy FORMAT Null;
+SHOW CREATE ROW POLICY sqllt_policy FORMAT Null;
 
 SHOW CREATE ROW POLICY sqllt_row_policy FORMAT Null;
 
diff --git a/tests/clickhouse-reference/01999_grant_with_replace.sql.expected.ast.json b/tests/clickhouse-reference/01999_grant_with_replace.sql.expected.ast.json
index 5115ef08a..6c4c557e1 100644
--- a/tests/clickhouse-reference/01999_grant_with_replace.sql.expected.ast.json
+++ b/tests/clickhouse-reference/01999_grant_with_replace.sql.expected.ast.json
@@ -15,40 +15,229 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER test_user_01999"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "test_user_01999"
+        }
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW GRANTS FOR test_user_01999"
+    "kind": "show",
+    "show": {
+      "type": "grants",
+      "for": [
+        "test_user_01999"
+      ]
+    }
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON db1.* TO test_user_01999"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db1",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01999"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SHOW ON db2.tb2 TO test_user_01999"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SHOW"
+          }
+        ],
+        "target": {
+          "database": "db2",
+          "table": "tb2"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01999"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT(col1) ON db3.table TO test_user_01999 WITH REPLACE OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "col1"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db3",
+          "table": "table"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01999"
+    ],
+    "withOptions": [
+      "REPLACE"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT(col3) ON db3.table3, SELECT(col1, col2) ON db4.table4 TO test_user_01999 WITH REPLACE OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "col3"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db3",
+          "table": "table3"
+        }
+      },
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "col1",
+              "col2"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db4",
+          "table": "table4"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01999"
+    ],
+    "withOptions": [
+      "REPLACE"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT(cola) ON db5.table, INSERT(colb) ON db6.tb61, SHOW ON db7.* TO test_user_01999 WITH REPLACE OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT",
+            "columns": [
+              "cola"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db5",
+          "table": "table"
+        }
+      },
+      {
+        "privileges": [
+          {
+            "name": "INSERT",
+            "columns": [
+              "colb"
+            ]
+          }
+        ],
+        "target": {
+          "database": "db6",
+          "table": "tb61"
+        }
+      },
+      {
+        "privileges": [
+          {
+            "name": "SHOW"
+          }
+        ],
+        "target": {
+          "database": "db7",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01999"
+    ],
+    "withOptions": [
+      "REPLACE"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON all.* TO test_user_01999 WITH REPLACE OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "all",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01999"
+    ],
+    "withOptions": [
+      "REPLACE"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT USAGE ON *.* TO test_user_01999 WITH REPLACE OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "USAGE"
+          }
+        ],
+        "target": {
+          "database": "*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01999"
+    ],
+    "withOptions": [
+      "REPLACE"
+    ]
   },
   {
     "kind": "system",
@@ -63,28 +252,124 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "GRANT test_role_01999 to test_user_01999"
+    "kind": "grant",
+    "operation": "GRANT",
+    "roles": [
+      "test_role_01999"
+    ],
+    "grantees": [
+      "test_user_01999"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON db1.tb1 TO test_user_01999"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db1",
+          "table": "tb1"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01999"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT NONE ON *.* TO test_user_01999 WITH REPLACE OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "NONE"
+          }
+        ],
+        "target": {
+          "database": "*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01999"
+    ],
+    "withOptions": [
+      "REPLACE"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SHOW ON db8.* TO test_user_01999"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SHOW"
+          }
+        ],
+        "target": {
+          "database": "db8",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01999"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT NONE TO test_user_01999 WITH REPLACE OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "roles": [
+      "NONE"
+    ],
+    "grantees": [
+      "test_user_01999"
+    ],
+    "withOptions": [
+      "REPLACE"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT NONE ON *.*, SELECT on db9.tb3 TO test_user_01999 WITH REPLACE OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "NONE"
+          }
+        ],
+        "target": {
+          "database": "*",
+          "table": "*"
+        }
+      },
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "db9",
+          "table": "tb3"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_01999"
+    ],
+    "withOptions": [
+      "REPLACE"
+    ]
   },
   {
     "kind": "system",
@@ -99,7 +384,17 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "GRANT NONE, test_role_01999_1 TO test_user_01999 WITH REPLACE OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "roles": [
+      "NONE",
+      "test_role_01999_1"
+    ],
+    "grantees": [
+      "test_user_01999"
+    ],
+    "withOptions": [
+      "REPLACE"
+    ]
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/01999_grant_with_replace.sql.expected.formatted.sql b/tests/clickhouse-reference/01999_grant_with_replace.sql.expected.formatted.sql
index b48692843..19d599844 100644
--- a/tests/clickhouse-reference/01999_grant_with_replace.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/01999_grant_with_replace.sql.expected.formatted.sql
@@ -25,7 +25,7 @@ DROP ROLE IF EXISTS test_role_01999;
 
 CREATE ROLE test_role_01999;
 
-GRANT test_role_01999 to test_user_01999;
+GRANT test_role_01999 TO test_user_01999;
 
 GRANT SELECT ON db1.tb1 TO test_user_01999;
 
@@ -35,7 +35,7 @@ GRANT SHOW ON db8.* TO test_user_01999;
 
 GRANT NONE TO test_user_01999 WITH REPLACE OPTION;
 
-GRANT NONE ON *.*, SELECT on db9.tb3 TO test_user_01999 WITH REPLACE OPTION;
+GRANT NONE ON *.*, SELECT ON db9.tb3 TO test_user_01999 WITH REPLACE OPTION;
 
 DROP ROLE IF EXISTS test_role_01999_1;
 
diff --git a/tests/clickhouse-reference/02072_rdb_recovery_escaped_name.sql.expected.ast.json b/tests/clickhouse-reference/02072_rdb_recovery_escaped_name.sql.expected.ast.json
index bb6a4cc40..6d850a965 100644
--- a/tests/clickhouse-reference/02072_rdb_recovery_escaped_name.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02072_rdb_recovery_escaped_name.sql.expected.ast.json
@@ -91,8 +91,16 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier}"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      }
+    }
   },
   {
     "kind": "createDatabase",
@@ -139,8 +147,16 @@
     "body": "SYSTEM SYNC DATABASE REPLICA {CLICKHOUSE_DATABASE_1:Identifier}"
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE_1:Identifier}"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE_1",
+        "type": "Identifier"
+      }
+    }
   },
   {
     "kind": "drop",
diff --git a/tests/clickhouse-reference/02294_fp_seconds_profile.sql.expected.ast.json b/tests/clickhouse-reference/02294_fp_seconds_profile.sql.expected.ast.json
index 13deb308b..26e5f14de 100644
--- a/tests/clickhouse-reference/02294_fp_seconds_profile.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02294_fp_seconds_profile.sql.expected.ast.json
@@ -32,8 +32,16 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE SETTINGS PROFILE 02294_profile1"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "02294_profile1"
+        }
+      ]
+    }
   },
   {
     "kind": "createSettingsProfile",
@@ -60,7 +68,15 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE SETTINGS PROFILE 02294_profile2"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "SETTINGS PROFILE",
+      "names": [
+        {
+          "name": "02294_profile2"
+        }
+      ]
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/02294_fp_seconds_profile.sql.expected.formatted.sql b/tests/clickhouse-reference/02294_fp_seconds_profile.sql.expected.formatted.sql
index 86cbe167f..e499a2278 100644
--- a/tests/clickhouse-reference/02294_fp_seconds_profile.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/02294_fp_seconds_profile.sql.expected.formatted.sql
@@ -4,8 +4,8 @@ DROP SETTINGS PROFILE IF EXISTS 02294_profile1, 02294_profile2;
 
 CREATE SETTINGS PROFILE 02294_profile1 SETTINGS timeout_before_checking_execution_speed=3 TO default;
 
-SHOW CREATE SETTINGS PROFILE 02294_profile1;
+SHOW CREATE SETTINGS PROFILE `02294_profile1`;
 
 CREATE SETTINGS PROFILE 02294_profile2 SETTINGS max_execution_time=0.5 TO default;
 
-SHOW CREATE SETTINGS PROFILE 02294_profile2;
\ No newline at end of file
+SHOW CREATE SETTINGS PROFILE `02294_profile2`;
\ No newline at end of file
diff --git a/tests/clickhouse-reference/02345_implicit_transaction.sql.expected.ast.json b/tests/clickhouse-reference/02345_implicit_transaction.sql.expected.ast.json
index 91c6fbde4..9611d5bf0 100644
--- a/tests/clickhouse-reference/02345_implicit_transaction.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02345_implicit_transaction.sql.expected.ast.json
@@ -259,8 +259,8 @@
     }
   },
   {
-    "kind": "system",
-    "body": "BEGIN TRANSACTION"
+    "kind": "transactionControl",
+    "action": "begin"
   },
   {
     "kind": "insert",
@@ -295,8 +295,8 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "ROLLBACK"
+    "kind": "transactionControl",
+    "action": "rollback"
   },
   {
     "kind": "select",
diff --git a/tests/clickhouse-reference/02494_query_cache_eligible_queries.sql.expected.ast.json b/tests/clickhouse-reference/02494_query_cache_eligible_queries.sql.expected.ast.json
index 4584f28f9..156c5b0c0 100644
--- a/tests/clickhouse-reference/02494_query_cache_eligible_queries.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02494_query_cache_eligible_queries.sql.expected.ast.json
@@ -214,8 +214,21 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES SETTINGS use_query_cache = true",
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "settings": [
+        {
+          "name": "use_query_cache",
+          "value": {
+            "kind": "literal",
+            "type": "Bool",
+            "value": "1"
+          }
+        }
+      ]
+    },
     "leadingComments": [
       "-- SHOW"
     ]
diff --git a/tests/clickhouse-reference/02497_source_part_is_intact_when_mutation.sql.expected.ast.json b/tests/clickhouse-reference/02497_source_part_is_intact_when_mutation.sql.expected.ast.json
index f62b0d4ca..084d190ca 100644
--- a/tests/clickhouse-reference/02497_source_part_is_intact_when_mutation.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02497_source_part_is_intact_when_mutation.sql.expected.ast.json
@@ -203,8 +203,8 @@
     }
   },
   {
-    "kind": "system",
-    "body": "BEGIN TRANSACTION"
+    "kind": "transactionControl",
+    "action": "begin"
   },
   {
     "kind": "alter",
@@ -248,8 +248,8 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "ROLLBACK"
+    "kind": "transactionControl",
+    "action": "rollback"
   },
   {
     "kind": "alter",
diff --git a/tests/clickhouse-reference/02681_undrop_query.sql.expected.ast.json b/tests/clickhouse-reference/02681_undrop_query.sql.expected.ast.json
index 826f3dc76..b62760125 100644
--- a/tests/clickhouse-reference/02681_undrop_query.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02681_undrop_query.sql.expected.ast.json
@@ -111,8 +111,11 @@
     }
   },
   {
-    "kind": "system",
-    "body": "undrop table 02681_undrop_mergetree"
+    "kind": "undrop",
+    "table": {
+      "kind": "tableRef",
+      "table": "02681_undrop_mergetree"
+    }
   },
   {
     "kind": "select",
@@ -212,8 +215,11 @@
     "sync": true
   },
   {
-    "kind": "system",
-    "body": "undrop table 02681_undrop_detach",
+    "kind": "undrop",
+    "table": {
+      "kind": "tableRef",
+      "table": "02681_undrop_detach"
+    },
     "trailingComments": [
       "-- { serverError TABLE_ALREADY_EXISTS }"
     ]
@@ -433,8 +439,13 @@
     }
   },
   {
-    "kind": "system",
-    "body": "undrop table 02681_undrop_uuid_on_cluster on cluster test_shard_localhost format Null"
+    "kind": "undrop",
+    "table": {
+      "kind": "tableRef",
+      "table": "02681_undrop_uuid_on_cluster"
+    },
+    "onCluster": "test_shard_localhost",
+    "format": "Null"
   },
   {
     "kind": "select",
@@ -570,8 +581,13 @@
     }
   },
   {
-    "kind": "system",
-    "body": "undrop table 02681_undrop_no_uuid_on_cluster on cluster test_shard_localhost format Null"
+    "kind": "undrop",
+    "table": {
+      "kind": "tableRef",
+      "table": "02681_undrop_no_uuid_on_cluster"
+    },
+    "onCluster": "test_shard_localhost",
+    "format": "Null"
   },
   {
     "kind": "select",
@@ -714,8 +730,11 @@
     }
   },
   {
-    "kind": "system",
-    "body": "undrop table 02681_undrop_replicatedmergetree"
+    "kind": "undrop",
+    "table": {
+      "kind": "tableRef",
+      "table": "02681_undrop_replicatedmergetree"
+    }
   },
   {
     "kind": "select",
@@ -835,8 +854,11 @@
     }
   },
   {
-    "kind": "system",
-    "body": "undrop table 02681_undrop_log"
+    "kind": "undrop",
+    "table": {
+      "kind": "tableRef",
+      "table": "02681_undrop_log"
+    }
   },
   {
     "kind": "select",
@@ -969,8 +991,11 @@
     }
   },
   {
-    "kind": "system",
-    "body": "undrop table 02681_undrop_distributed"
+    "kind": "undrop",
+    "table": {
+      "kind": "tableRef",
+      "table": "02681_undrop_distributed"
+    }
   },
   {
     "kind": "drop",
@@ -1096,8 +1121,11 @@
     }
   },
   {
-    "kind": "system",
-    "body": "undrop table 02681_undrop_multiple"
+    "kind": "undrop",
+    "table": {
+      "kind": "tableRef",
+      "table": "02681_undrop_multiple"
+    }
   },
   {
     "kind": "select",
diff --git a/tests/clickhouse-reference/02681_undrop_query.sql.expected.formatted.sql b/tests/clickhouse-reference/02681_undrop_query.sql.expected.formatted.sql
index 0f8a71dac..e43284a1d 100644
--- a/tests/clickhouse-reference/02681_undrop_query.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/02681_undrop_query.sql.expected.formatted.sql
@@ -19,7 +19,7 @@ FROM `system`.dropped_tables
 WHERE table = '02681_undrop_mergetree'
 LIMIT 1;
 
-undrop table 02681_undrop_mergetree;
+UNDROP TABLE `02681_undrop_mergetree`;
 
 SELECT *
 FROM `02681_undrop_mergetree`
@@ -41,7 +41,7 @@ INSERT INTO `02681_undrop_detach`;
 
 DETACH TABLE `02681_undrop_detach` SYNC;
 
-undrop table 02681_undrop_detach; -- { serverError TABLE_ALREADY_EXISTS }
+UNDROP TABLE `02681_undrop_detach`; -- { serverError TABLE_ALREADY_EXISTS }
 
 ATTACH TABLE `02681_undrop_detach`;
 
@@ -74,7 +74,7 @@ FROM `system`.dropped_tables
 WHERE table = '02681_undrop_uuid_on_cluster'
 LIMIT 1;
 
-undrop table 02681_undrop_uuid_on_cluster on cluster test_shard_localhost format Null;
+UNDROP TABLE `02681_undrop_uuid_on_cluster` ON CLUSTER test_shard_localhost FORMAT Null;
 
 SELECT *
 FROM `02681_undrop_uuid_on_cluster`
@@ -101,7 +101,7 @@ FROM `system`.dropped_tables
 WHERE table = '02681_undrop_no_uuid_on_cluster'
 LIMIT 1;
 
-undrop table 02681_undrop_no_uuid_on_cluster on cluster test_shard_localhost format Null;
+UNDROP TABLE `02681_undrop_no_uuid_on_cluster` ON CLUSTER test_shard_localhost FORMAT Null;
 
 SELECT *
 FROM `02681_undrop_no_uuid_on_cluster`
@@ -127,7 +127,7 @@ FROM `system`.dropped_tables
 WHERE table = '02681_undrop_replicatedmergetree'
 LIMIT 1;
 
-undrop table 02681_undrop_replicatedmergetree;
+UNDROP TABLE `02681_undrop_replicatedmergetree`;
 
 SELECT *
 FROM `02681_undrop_replicatedmergetree`
@@ -152,7 +152,7 @@ FROM `system`.dropped_tables
 WHERE table = '02681_undrop_log'
 LIMIT 1;
 
-undrop table 02681_undrop_log;
+UNDROP TABLE `02681_undrop_log`;
 
 SELECT *
 FROM `02681_undrop_log`
@@ -175,7 +175,7 @@ FROM `system`.dropped_tables
 WHERE table = '02681_undrop_distributed'
 LIMIT 1;
 
-undrop table 02681_undrop_distributed;
+UNDROP TABLE `02681_undrop_distributed`;
 
 DROP TABLE `02681_undrop_distributed`;
 
@@ -201,7 +201,7 @@ FROM `system`.dropped_tables
 WHERE table = '02681_undrop_multiple'
 LIMIT 1;
 
-undrop table 02681_undrop_multiple;
+UNDROP TABLE `02681_undrop_multiple`;
 
 SELECT *
 FROM `02681_undrop_multiple`
diff --git a/tests/clickhouse-reference/02706_show_columns.sql.expected.ast.json b/tests/clickhouse-reference/02706_show_columns.sql.expected.ast.json
index d0394d4af..0864b8a7f 100644
--- a/tests/clickhouse-reference/02706_show_columns.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02706_show_columns.sql.expected.ast.json
@@ -113,44 +113,154 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM tab"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW FIELDS FROM tab"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "FIELDS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW EXTENDED COLUMNS FROM tab"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      },
+      "extended": true
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW FULL COLUMNS FROM tab"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      },
+      "full": true
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM tab LIKE '%int%'"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      },
+      "like": {
+        "pattern": "%int%"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM tab NOT LIKE '%int%'"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      },
+      "like": {
+        "pattern": "%int%",
+        "not": true
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM tab ILIKE '%INT%'"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      },
+      "like": {
+        "pattern": "%INT%",
+        "ilike": true
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM tab NOT ILIKE '%INT%'"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      },
+      "like": {
+        "pattern": "%INT%",
+        "not": true,
+        "ilike": true
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM tab WHERE field LIKE '%int%'"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      },
+      "where": {
+        "kind": "functionCall",
+        "name": "like",
+        "args": [
+          {
+            "kind": "columnRef",
+            "parts": [
+              "field"
+            ]
+          },
+          {
+            "kind": "literal",
+            "type": "String",
+            "value": "%int%"
+          }
+        ]
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM tab LIMIT 1"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      },
+      "limit": {
+        "kind": "literal",
+        "type": "UInt64",
+        "value": "1"
+      }
+    }
   },
   {
     "kind": "drop",
@@ -191,8 +301,15 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM `$4@^7`"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "$4@^7"
+      }
+    }
   },
   {
     "kind": "drop",
@@ -241,8 +358,15 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM NULL"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "NULL"
+      }
+    }
   },
   {
     "kind": "drop",
@@ -291,8 +415,15 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM `tab.with.dots`"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab.with.dots"
+      }
+    }
   },
   {
     "kind": "drop",
@@ -346,12 +477,28 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM `'` FROM `'`"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "'"
+      },
+      "from": "'"
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM `'`.`'`",
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "database": "'",
+        "table": "'"
+      }
+    },
     "trailingComments": [
       "-- abbreviated form"
     ]
@@ -448,12 +595,28 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM tab FROM database_123456789abcde"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      },
+      "from": "database_123456789abcde"
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM database_123456789abcde.tab"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "database": "database_123456789abcde",
+        "table": "tab"
+      }
+    }
   },
   {
     "kind": "drop",
diff --git a/tests/clickhouse-reference/02706_show_columns.sql.expected.formatted.sql b/tests/clickhouse-reference/02706_show_columns.sql.expected.formatted.sql
index 6d39db16c..63a480f64 100644
--- a/tests/clickhouse-reference/02706_show_columns.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/02706_show_columns.sql.expected.formatted.sql
@@ -33,7 +33,7 @@ SHOW COLUMNS FROM tab ILIKE '%INT%';
 
 SHOW COLUMNS FROM tab NOT ILIKE '%INT%';
 
-SHOW COLUMNS FROM tab WHERE field LIKE '%int%';
+SHOW COLUMNS FROM tab WHERE like(field, '%int%');
 
 SHOW COLUMNS FROM tab LIMIT 1;
 
@@ -59,7 +59,7 @@ CREATE TABLE `NULL`
 ENGINE = MergeTree
 ORDER BY c;
 
-SHOW COLUMNS FROM NULL;
+SHOW COLUMNS FROM `NULL`;
 
 DROP TABLE `NULL`;
 
diff --git a/tests/clickhouse-reference/02710_show_table.sql.expected.ast.json b/tests/clickhouse-reference/02710_show_table.sql.expected.ast.json
index 130dce65e..d1390e0f8 100644
--- a/tests/clickhouse-reference/02710_show_table.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02710_show_table.sql.expected.ast.json
@@ -38,8 +38,15 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLE t_2710_show_table"
+    "kind": "show",
+    "show": {
+      "type": "objectShorthand",
+      "objectType": "TABLE",
+      "table": {
+        "kind": "tableRef",
+        "table": "t_2710_show_table"
+      }
+    }
   },
   {
     "kind": "showCreate",
@@ -82,8 +89,11 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW DATABASE t_2710_db"
+    "kind": "show",
+    "show": {
+      "type": "databaseShorthand",
+      "database": "t_2710_db"
+    }
   },
   {
     "kind": "showCreate",
diff --git a/tests/clickhouse-reference/02724_show_indexes.sql.expected.ast.json b/tests/clickhouse-reference/02724_show_indexes.sql.expected.ast.json
index 63e1311c5..f428354dc 100644
--- a/tests/clickhouse-reference/02724_show_indexes.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02724_show_indexes.sql.expected.ast.json
@@ -212,28 +212,88 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW INDEX FROM tbl"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDEX",
+      "table": {
+        "kind": "tableRef",
+        "table": "tbl"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW INDEXES FROM tbl"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDEXES",
+      "table": {
+        "kind": "tableRef",
+        "table": "tbl"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW INDICES FROM tbl"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDICES",
+      "table": {
+        "kind": "tableRef",
+        "table": "tbl"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW KEYS FROM tbl"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "KEYS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tbl"
+      }
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW EXTENDED INDEX FROM tbl"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDEX",
+      "table": {
+        "kind": "tableRef",
+        "table": "tbl"
+      },
+      "extended": true
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW INDEX FROM tbl WHERE index_type LIKE '%minmax%'"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDEX",
+      "table": {
+        "kind": "tableRef",
+        "table": "tbl"
+      },
+      "where": {
+        "kind": "functionCall",
+        "name": "like",
+        "args": [
+          {
+            "kind": "columnRef",
+            "parts": [
+              "index_type"
+            ]
+          },
+          {
+            "kind": "literal",
+            "type": "String",
+            "value": "%minmax%"
+          }
+        ]
+      }
+    }
   },
   {
     "kind": "drop",
@@ -285,8 +345,15 @@
     "settingsAfterOrderBy": true
   },
   {
-    "kind": "system",
-    "body": "SHOW INDEX FROM `$4@^7`"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDEX",
+      "table": {
+        "kind": "tableRef",
+        "table": "$4@^7"
+      }
+    }
   },
   {
     "kind": "drop",
@@ -346,8 +413,15 @@
     "settingsAfterOrderBy": true
   },
   {
-    "kind": "system",
-    "body": "SHOW INDEX FROM NULL"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDEX",
+      "table": {
+        "kind": "tableRef",
+        "table": "NULL"
+      }
+    }
   },
   {
     "kind": "drop",
@@ -553,8 +627,15 @@
     "settingsAfterOrderBy": true
   },
   {
-    "kind": "system",
-    "body": "SHOW INDEX FROM `tab.with.dots`"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDEX",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab.with.dots"
+      }
+    }
   },
   {
     "kind": "drop",
@@ -619,12 +700,28 @@
     "settingsAfterOrderBy": true
   },
   {
-    "kind": "system",
-    "body": "SHOW INDEX FROM `'` FROM `'`"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDEX",
+      "table": {
+        "kind": "tableRef",
+        "table": "'"
+      },
+      "from": "'"
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW INDEX FROM `'`.`'`",
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDEX",
+      "table": {
+        "kind": "tableRef",
+        "database": "'",
+        "table": "'"
+      }
+    },
     "trailingComments": [
       "-- abbreviated form"
     ]
@@ -736,12 +833,28 @@
     "settingsAfterOrderBy": true
   },
   {
-    "kind": "system",
-    "body": "SHOW INDEX FROM tbl FROM database_123456789abcde"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDEX",
+      "table": {
+        "kind": "tableRef",
+        "table": "tbl"
+      },
+      "from": "database_123456789abcde"
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW INDEX FROM database_123456789abcde.tbl"
+    "kind": "show",
+    "show": {
+      "type": "indexes",
+      "keyword": "INDEX",
+      "table": {
+        "kind": "tableRef",
+        "database": "database_123456789abcde",
+        "table": "tbl"
+      }
+    }
   },
   {
     "kind": "drop",
diff --git a/tests/clickhouse-reference/02724_show_indexes.sql.expected.formatted.sql b/tests/clickhouse-reference/02724_show_indexes.sql.expected.formatted.sql
index 5e0831a43..49ad9892c 100644
--- a/tests/clickhouse-reference/02724_show_indexes.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/02724_show_indexes.sql.expected.formatted.sql
@@ -33,7 +33,7 @@ SHOW KEYS FROM tbl;
 
 SHOW EXTENDED INDEX FROM tbl;
 
-SHOW INDEX FROM tbl WHERE index_type LIKE '%minmax%';
+SHOW INDEX FROM tbl WHERE like(index_type, '%minmax%');
 
 DROP TABLE IF EXISTS `$4@^7`;
 
@@ -59,7 +59,7 @@ ENGINE = MergeTree
 ORDER BY c
 SETTINGS add_minmax_index_for_numeric_columns = 0;
 
-SHOW INDEX FROM NULL;
+SHOW INDEX FROM `NULL`;
 
 DROP TABLE `NULL`;
 
diff --git a/tests/clickhouse-reference/02775_show_columns_called_from_clickhouse.sql.expected.ast.json b/tests/clickhouse-reference/02775_show_columns_called_from_clickhouse.sql.expected.ast.json
index 8528d2b92..e1778d745 100644
--- a/tests/clickhouse-reference/02775_show_columns_called_from_clickhouse.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02775_show_columns_called_from_clickhouse.sql.expected.ast.json
@@ -920,8 +920,15 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS FROM tab"
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "tab"
+      }
+    }
   },
   {
     "kind": "drop",
diff --git a/tests/clickhouse-reference/02842_truncate_database.sql.expected.ast.json b/tests/clickhouse-reference/02842_truncate_database.sql.expected.ast.json
index 9f29af846..0101ef581 100644
--- a/tests/clickhouse-reference/02842_truncate_database.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02842_truncate_database.sql.expected.ast.json
@@ -785,12 +785,20 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM test_truncate_database"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": "test_truncate_database"
+    }
   },
   {
-    "kind": "system",
-    "body": "SHOW DICTIONARIES FROM test_truncate_database"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "DICTIONARIES",
+      "from": "test_truncate_database"
+    }
   },
   {
     "kind": "truncate",
diff --git a/tests/clickhouse-reference/02867_create_user_ssh.sql.expected.ast.json b/tests/clickhouse-reference/02867_create_user_ssh.sql.expected.ast.json
index 012bc4485..2ddca7538 100644
--- a/tests/clickhouse-reference/02867_create_user_ssh.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02867_create_user_ssh.sql.expected.ast.json
@@ -16,7 +16,12 @@
     ],
     "auth": [
       {
-        "sshKeys": 1
+        "sshKeys": [
+          {
+            "key": "invalid_key",
+            "type": "ssh-rsa"
+          }
+        ]
       }
     ],
     "leadingComments": [
@@ -35,7 +40,16 @@
     ],
     "auth": [
       {
-        "sshKeys": 2
+        "sshKeys": [
+          {
+            "key": "invalid_key",
+            "type": "ssh-rsa"
+          },
+          {
+            "key": "invalid_key",
+            "type": "ssh-rsa"
+          }
+        ]
       }
     ],
     "trailingComments": [
@@ -51,7 +65,12 @@
     ],
     "auth": [
       {
-        "sshKeys": 1
+        "sshKeys": [
+          {
+            "key": "AAAAB3NzaC1yc2EAAAADAQABAAABgQCVTUso7/LQcBljfsHwyuL6fWfIvS3BaVpYB8lwf/ZylSOltBy6YlABtTU3mIb197d2DW99RcLKk174f5Zj5rUukXbV0fnufWvwd37fbb1eKM8zxBYvXs53EI5QBPZgKACIzMpYYZeJnAP0oZhUfWWtKXpy/SQ5CHiEIGD9RNYDL+uXZejMwC5r/+f2AmrATBo+Y+WJFZIvhj4uznFYvyvNTUz/YDvZCk+vwwIgiv4BpFCaZm2TeETTj6SvK567bZznLP5HXrkVbB5lhxjAkahc2w/Yjm//Fwto3xsMoJwROxJEU8L1kZ40QWPqjo7Tmr6C/hL2cKDNgWOEqrjLKQmh576s1+PfxwXpVPjLK4PHVSvuJLV88sn0iPdspLlKlDCdc7T9MqIrjJfxuhqnaoFQ7U+oBte8vkm1wGu76+WEC3iNWVAiIVZxLx9rUEsDqj3OovqfLiRsTmNLeY94p2asZjkx7rU48ZwuYN5XGafYsArPscj9Ve6RoRrof+5Q7cc=",
+            "type": "invalid_algorithm"
+          }
+        ]
       }
     ],
     "trailingComments": [
@@ -67,13 +86,26 @@
     ],
     "auth": [
       {
-        "sshKeys": 1
+        "sshKeys": [
+          {
+            "key": "AAAAB3NzaC1yc2EAAAADAQABAAABgQCVTUso7/LQcBljfsHwyuL6fWfIvS3BaVpYB8lwf/ZylSOltBy6YlABtTU3mIb197d2DW99RcLKk174f5Zj5rUukXbV0fnufWvwd37fbb1eKM8zxBYvXs53EI5QBPZgKACIzMpYYZeJnAP0oZhUfWWtKXpy/SQ5CHiEIGD9RNYDL+uXZejMwC5r/+f2AmrATBo+Y+WJFZIvhj4uznFYvyvNTUz/YDvZCk+vwwIgiv4BpFCaZm2TeETTj6SvK567bZznLP5HXrkVbB5lhxjAkahc2w/Yjm//Fwto3xsMoJwROxJEU8L1kZ40QWPqjo7Tmr6C/hL2cKDNgWOEqrjLKQmh576s1+PfxwXpVPjLK4PHVSvuJLV88sn0iPdspLlKlDCdc7T9MqIrjJfxuhqnaoFQ7U+oBte8vkm1wGu76+WEC3iNWVAiIVZxLx9rUEsDqj3OovqfLiRsTmNLeY94p2asZjkx7rU48ZwuYN5XGafYsArPscj9Ve6RoRrof+5Q7cc=",
+            "type": "ssh-rsa"
+          }
+        ]
       }
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER test_user_02867"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "test_user_02867"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/02867_create_user_ssh.sql.expected.formatted.sql b/tests/clickhouse-reference/02867_create_user_ssh.sql.expected.formatted.sql
index 895837d14..ec7ec1dd7 100644
--- a/tests/clickhouse-reference/02867_create_user_ssh.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/02867_create_user_ssh.sql.expected.formatted.sql
@@ -3,13 +3,13 @@
 DROP USER IF EXISTS test_user_02867;
 
 -- negative tests
-CREATE USER test_user_02867 IDENTIFIED WITH ssh_key BY KEY 'key0' TYPE 'ssh-rsa'; -- { serverError LIBSSH_ERROR }
+CREATE USER test_user_02867 IDENTIFIED WITH ssh_key BY KEY 'invalid_key' TYPE 'ssh-rsa'; -- { serverError LIBSSH_ERROR }
 
-CREATE USER test_user_02867 IDENTIFIED WITH ssh_key BY KEY 'key0' TYPE 'ssh-rsa', KEY 'key1' TYPE 'ssh-rsa'; -- { serverError LIBSSH_ERROR }
+CREATE USER test_user_02867 IDENTIFIED WITH ssh_key BY KEY 'invalid_key' TYPE 'ssh-rsa', KEY 'invalid_key' TYPE 'ssh-rsa'; -- { serverError LIBSSH_ERROR }
 
-CREATE USER test_user_02867 IDENTIFIED WITH ssh_key BY KEY 'key0' TYPE 'ssh-rsa'; -- { serverError LIBSSH_ERROR }
+CREATE USER test_user_02867 IDENTIFIED WITH ssh_key BY KEY 'AAAAB3NzaC1yc2EAAAADAQABAAABgQCVTUso7/LQcBljfsHwyuL6fWfIvS3BaVpYB8lwf/ZylSOltBy6YlABtTU3mIb197d2DW99RcLKk174f5Zj5rUukXbV0fnufWvwd37fbb1eKM8zxBYvXs53EI5QBPZgKACIzMpYYZeJnAP0oZhUfWWtKXpy/SQ5CHiEIGD9RNYDL+uXZejMwC5r/+f2AmrATBo+Y+WJFZIvhj4uznFYvyvNTUz/YDvZCk+vwwIgiv4BpFCaZm2TeETTj6SvK567bZznLP5HXrkVbB5lhxjAkahc2w/Yjm//Fwto3xsMoJwROxJEU8L1kZ40QWPqjo7Tmr6C/hL2cKDNgWOEqrjLKQmh576s1+PfxwXpVPjLK4PHVSvuJLV88sn0iPdspLlKlDCdc7T9MqIrjJfxuhqnaoFQ7U+oBte8vkm1wGu76+WEC3iNWVAiIVZxLx9rUEsDqj3OovqfLiRsTmNLeY94p2asZjkx7rU48ZwuYN5XGafYsArPscj9Ve6RoRrof+5Q7cc=' TYPE 'invalid_algorithm'; -- { serverError LIBSSH_ERROR }
 
-CREATE USER test_user_02867 IDENTIFIED WITH ssh_key BY KEY 'key0' TYPE 'ssh-rsa';
+CREATE USER test_user_02867 IDENTIFIED WITH ssh_key BY KEY 'AAAAB3NzaC1yc2EAAAADAQABAAABgQCVTUso7/LQcBljfsHwyuL6fWfIvS3BaVpYB8lwf/ZylSOltBy6YlABtTU3mIb197d2DW99RcLKk174f5Zj5rUukXbV0fnufWvwd37fbb1eKM8zxBYvXs53EI5QBPZgKACIzMpYYZeJnAP0oZhUfWWtKXpy/SQ5CHiEIGD9RNYDL+uXZejMwC5r/+f2AmrATBo+Y+WJFZIvhj4uznFYvyvNTUz/YDvZCk+vwwIgiv4BpFCaZm2TeETTj6SvK567bZznLP5HXrkVbB5lhxjAkahc2w/Yjm//Fwto3xsMoJwROxJEU8L1kZ40QWPqjo7Tmr6C/hL2cKDNgWOEqrjLKQmh576s1+PfxwXpVPjLK4PHVSvuJLV88sn0iPdspLlKlDCdc7T9MqIrjJfxuhqnaoFQ7U+oBte8vkm1wGu76+WEC3iNWVAiIVZxLx9rUEsDqj3OovqfLiRsTmNLeY94p2asZjkx7rU48ZwuYN5XGafYsArPscj9Ve6RoRrof+5Q7cc=' TYPE 'ssh-rsa';
 
 SHOW CREATE USER test_user_02867;
 
diff --git a/tests/clickhouse-reference/02891_rename_table_without_keyword.sql.expected.ast.json b/tests/clickhouse-reference/02891_rename_table_without_keyword.sql.expected.ast.json
index dc10cef58..cf6ec9c65 100644
--- a/tests/clickhouse-reference/02891_rename_table_without_keyword.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02891_rename_table_without_keyword.sql.expected.ast.json
@@ -48,8 +48,16 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLES FROM {CLICKHOUSE_DATABASE:Identifier}"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "TABLES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      }
+    }
   },
   {
     "kind": "rename",
@@ -266,8 +274,16 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW DICTIONARIES FROM {CLICKHOUSE_DATABASE:Identifier}"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "DICTIONARIES",
+      "from": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      }
+    }
   },
   {
     "kind": "rename",
@@ -296,8 +312,14 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW DATABASES LIKE '{CLICKHOUSE_DATABASE:String}'"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "DATABASES",
+      "like": {
+        "pattern": "{CLICKHOUSE_DATABASE:String}"
+      }
+    }
   },
   {
     "kind": "rename",
diff --git a/tests/clickhouse-reference/02902_show_databases_limit.sql.expected.ast.json b/tests/clickhouse-reference/02902_show_databases_limit.sql.expected.ast.json
index 0f6956c2c..31e6b04a4 100644
--- a/tests/clickhouse-reference/02902_show_databases_limit.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02902_show_databases_limit.sql.expected.ast.json
@@ -1,6 +1,14 @@
 [
   {
-    "kind": "system",
-    "body": "SHOW DATABASES LIMIT 0"
+    "kind": "show",
+    "show": {
+      "type": "listing",
+      "objectType": "DATABASES",
+      "limit": {
+        "kind": "literal",
+        "type": "UInt64",
+        "value": "0"
+      }
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/02905_show_setting_query.sql.expected.ast.json b/tests/clickhouse-reference/02905_show_setting_query.sql.expected.ast.json
index 08e11298d..e24282575 100644
--- a/tests/clickhouse-reference/02905_show_setting_query.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02905_show_setting_query.sql.expected.ast.json
@@ -13,8 +13,11 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW SETTING max_threads"
+    "kind": "show",
+    "show": {
+      "type": "setting",
+      "name": "max_threads"
+    }
   },
   {
     "kind": "set",
@@ -30,7 +33,10 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW SETTING `max_threads' OR name = 'max_memory_usage`"
+    "kind": "show",
+    "show": {
+      "type": "setting",
+      "name": "max_threads' OR name = 'max_memory_usage"
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/02960_alter_table_part_query_parameter.sql.expected.ast.json b/tests/clickhouse-reference/02960_alter_table_part_query_parameter.sql.expected.ast.json
index 7f823c07a..9d9a570f8 100644
--- a/tests/clickhouse-reference/02960_alter_table_part_query_parameter.sql.expected.ast.json
+++ b/tests/clickhouse-reference/02960_alter_table_part_query_parameter.sql.expected.ast.json
@@ -62,12 +62,40 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "alter table data detach part {part:String}"
+    "kind": "alter",
+    "table": {
+      "kind": "tableRef",
+      "table": "data"
+    },
+    "commands": [
+      {
+        "kind": "alterCommand",
+        "commandType": "DROP_PARTITION",
+        "partName": {
+          "kind": "queryParam",
+          "name": "part",
+          "type": "String"
+        }
+      }
+    ]
   },
   {
-    "kind": "system",
-    "body": "alter table data attach part {part:String}"
+    "kind": "alter",
+    "table": {
+      "kind": "tableRef",
+      "table": "data"
+    },
+    "commands": [
+      {
+        "kind": "alterCommand",
+        "commandType": "ATTACH_PARTITION",
+        "partName": {
+          "kind": "queryParam",
+          "name": "part",
+          "type": "String"
+        }
+      }
+    ]
   },
   {
     "kind": "set",
@@ -83,8 +111,32 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "alter table data drop detached part {part:String} settings allow_drop_detached=1"
+    "kind": "alter",
+    "table": {
+      "kind": "tableRef",
+      "table": "data"
+    },
+    "commands": [
+      {
+        "kind": "alterCommand",
+        "commandType": "DROP_DETACHED_PARTITION",
+        "partName": {
+          "kind": "queryParam",
+          "name": "part",
+          "type": "String"
+        }
+      }
+    ],
+    "settings": [
+      {
+        "name": "allow_drop_detached",
+        "value": {
+          "kind": "literal",
+          "type": "UInt64",
+          "value": "1"
+        }
+      }
+    ]
   },
   {
     "kind": "insert",
@@ -110,7 +162,21 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "alter table data drop part {part:String}"
+    "kind": "alter",
+    "table": {
+      "kind": "tableRef",
+      "table": "data"
+    },
+    "commands": [
+      {
+        "kind": "alterCommand",
+        "commandType": "DROP_PARTITION",
+        "partName": {
+          "kind": "queryParam",
+          "name": "part",
+          "type": "String"
+        }
+      }
+    ]
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/02960_alter_table_part_query_parameter.sql.expected.formatted.sql b/tests/clickhouse-reference/02960_alter_table_part_query_parameter.sql.expected.formatted.sql
index 0cfe06380..3847e2f02 100644
--- a/tests/clickhouse-reference/02960_alter_table_part_query_parameter.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/02960_alter_table_part_query_parameter.sql.expected.formatted.sql
@@ -11,16 +11,16 @@ INSERT INTO data;
 
 SET param_part = 'all_1_1_0';
 
-alter table data detach part {part:String};
+ALTER TABLE data DROP PART {part:String};
 
-alter table data attach part {part:String};
+ALTER TABLE data ATTACH PART {part:String};
 
 SET param_part = 'all_2_2_0';
 
-alter table data drop detached part {part:String} settings allow_drop_detached=1;
+ALTER TABLE data DROP DETACHED PART {part:String} SETTINGS allow_drop_detached = 1;
 
 INSERT INTO data;
 
 SET param_part = 'all_3_3_0';
 
-alter table data drop part {part:String};
\ No newline at end of file
+ALTER TABLE data DROP PART {part:String};
\ No newline at end of file
diff --git a/tests/clickhouse-reference/03141_wildcard_grants.sql.expected.ast.json b/tests/clickhouse-reference/03141_wildcard_grants.sql.expected.ast.json
index c7419d1d9..9cff0a639 100644
--- a/tests/clickhouse-reference/03141_wildcard_grants.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03141_wildcard_grants.sql.expected.ast.json
@@ -15,20 +15,73 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON test*.* TO user_03141"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "test*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "user_03141"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SELECT ON team*.* TO user_03141"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "team*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "user_03141"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT INSERT ON team*.* TO user_03141"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "INSERT"
+          }
+        ],
+        "target": {
+          "database": "team*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "user_03141"
+    ]
   },
   {
-    "kind": "system",
-    "body": "SHOW GRANTS FOR user_03141"
+    "kind": "show",
+    "show": {
+      "type": "grants",
+      "for": [
+        "user_03141"
+      ]
+    }
   },
   {
     "kind": "select",
@@ -41,20 +94,85 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "GRANT INSERT ON foo* TO user_03141"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "INSERT"
+          }
+        ],
+        "target": {
+          "table": "foo*"
+        }
+      }
+    ],
+    "grantees": [
+      "user_03141"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT INSERT ON foobar* TO user_03141 WITH GRANT OPTION"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "INSERT"
+          }
+        ],
+        "target": {
+          "table": "foobar*"
+        }
+      }
+    ],
+    "grantees": [
+      "user_03141"
+    ],
+    "withOptions": [
+      "GRANT"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT ON test.* FROM user_03141"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "test",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "user_03141"
+    ]
   },
   {
-    "kind": "system",
-    "body": "REVOKE SELECT ON team*.* FROM user_03141"
+    "kind": "grant",
+    "operation": "REVOKE",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SELECT"
+          }
+        ],
+        "target": {
+          "database": "team*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "user_03141"
+    ]
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/03174_multiple_authentication_methods_show_create.sql.expected.ast.json b/tests/clickhouse-reference/03174_multiple_authentication_methods_show_create.sql.expected.ast.json
index a9a7ffa1f..0fc63ea98 100644
--- a/tests/clickhouse-reference/03174_multiple_authentication_methods_show_create.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03174_multiple_authentication_methods_show_create.sql.expected.ast.json
@@ -26,8 +26,16 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER u_03174_multiple_auth_show_create"
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "u_03174_multiple_auth_show_create"
+        }
+      ]
+    }
   },
   {
     "kind": "system",
diff --git a/tests/clickhouse-reference/03282_memory_transaction_crash.sql.expected.ast.json b/tests/clickhouse-reference/03282_memory_transaction_crash.sql.expected.ast.json
index c279b029f..bcf528e6e 100644
--- a/tests/clickhouse-reference/03282_memory_transaction_crash.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03282_memory_transaction_crash.sql.expected.ast.json
@@ -33,8 +33,8 @@
     }
   },
   {
-    "kind": "system",
-    "body": "BEGIN TRANSACTION"
+    "kind": "transactionControl",
+    "action": "begin"
   },
   {
     "kind": "explain",
@@ -84,7 +84,7 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "ROLLBACK"
+    "kind": "transactionControl",
+    "action": "rollback"
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/03286_backup_to_memory.sql.expected.ast.json b/tests/clickhouse-reference/03286_backup_to_memory.sql.expected.ast.json
index f82762535..2f91fd719 100644
--- a/tests/clickhouse-reference/03286_backup_to_memory.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03286_backup_to_memory.sql.expected.ast.json
@@ -48,8 +48,28 @@
     }
   },
   {
-    "kind": "system",
-    "body": "BACKUP TABLE t1 TO Memory('b1') FORMAT Null"
+    "kind": "backup",
+    "operation": "BACKUP",
+    "elements": [
+      {
+        "kind": "table",
+        "table": {
+          "kind": "tableRef",
+          "table": "t1"
+        }
+      }
+    ],
+    "destination": {
+      "name": "Memory",
+      "args": [
+        {
+          "kind": "literal",
+          "type": "String",
+          "value": "b1"
+        }
+      ]
+    },
+    "format": "Null"
   },
   {
     "kind": "drop",
@@ -60,8 +80,28 @@
     }
   },
   {
-    "kind": "system",
-    "body": "RESTORE TABLE t1 FROM Memory('b1') FORMAT Null"
+    "kind": "backup",
+    "operation": "RESTORE",
+    "elements": [
+      {
+        "kind": "table",
+        "table": {
+          "kind": "tableRef",
+          "table": "t1"
+        }
+      }
+    ],
+    "destination": {
+      "name": "Memory",
+      "args": [
+        {
+          "kind": "literal",
+          "type": "String",
+          "value": "b1"
+        }
+      ]
+    },
+    "format": "Null"
   },
   {
     "kind": "select",
diff --git a/tests/clickhouse-reference/03286_backup_to_null.sql.expected.ast.json b/tests/clickhouse-reference/03286_backup_to_null.sql.expected.ast.json
index 97e0abf7f..2bab340ce 100644
--- a/tests/clickhouse-reference/03286_backup_to_null.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03286_backup_to_null.sql.expected.ast.json
@@ -48,8 +48,21 @@
     }
   },
   {
-    "kind": "system",
-    "body": "BACKUP TABLE t1 TO Null FORMAT Null"
+    "kind": "backup",
+    "operation": "BACKUP",
+    "elements": [
+      {
+        "kind": "table",
+        "table": {
+          "kind": "tableRef",
+          "table": "t1"
+        }
+      }
+    ],
+    "destination": {
+      "name": "Null"
+    },
+    "format": "Null"
   },
   {
     "kind": "drop",
@@ -60,8 +73,21 @@
     }
   },
   {
-    "kind": "system",
-    "body": "RESTORE TABLE t1 FROM Null FORMAT Null",
+    "kind": "backup",
+    "operation": "RESTORE",
+    "elements": [
+      {
+        "kind": "table",
+        "table": {
+          "kind": "tableRef",
+          "table": "t1"
+        }
+      }
+    ],
+    "destination": {
+      "name": "Null"
+    },
+    "format": "Null",
     "trailingComments": [
       "-- { serverError BACKUP_NOT_FOUND }"
     ]
diff --git a/tests/clickhouse-reference/03442_detach_view.sql.expected.ast.json b/tests/clickhouse-reference/03442_detach_view.sql.expected.ast.json
index 75c8e74ee..4864d0a8d 100644
--- a/tests/clickhouse-reference/03442_detach_view.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03442_detach_view.sql.expected.ast.json
@@ -97,7 +97,22 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "ALTER TABLE {CLICKHOUSE_DATABASE:Identifier}.v0 MODIFY REFRESH AFTER 1 SECOND APPEND"
+    "kind": "alter",
+    "table": {
+      "kind": "tableRef",
+      "database": {
+        "kind": "queryParam",
+        "name": "CLICKHOUSE_DATABASE",
+        "type": "Identifier"
+      },
+      "table": "v0"
+    },
+    "commands": [
+      {
+        "kind": "alterCommand",
+        "commandType": "MODIFY_REFRESH",
+        "refresh": "AFTER 1 SECOND APPEND"
+      }
+    ]
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/03532_create_user_query_on_wrong_parametric_grantees.sql.expected.ast.json b/tests/clickhouse-reference/03532_create_user_query_on_wrong_parametric_grantees.sql.expected.ast.json
index 7c7ef392e..c688d796e 100644
--- a/tests/clickhouse-reference/03532_create_user_query_on_wrong_parametric_grantees.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03532_create_user_query_on_wrong_parametric_grantees.sql.expected.ast.json
@@ -1,7 +1,15 @@
 [
   {
-    "kind": "system",
-    "body": "SHOW CREATE USER test_user_03532",
+    "kind": "show",
+    "show": {
+      "type": "createAccess",
+      "entity": "USER",
+      "names": [
+        {
+          "name": "test_user_03532"
+        }
+      ]
+    },
     "trailingComments": [
       "-- { serverError UNKNOWN_USER }"
     ]
diff --git a/tests/clickhouse-reference/03593_backup_with_broken_projection.sql.expected.ast.json b/tests/clickhouse-reference/03593_backup_with_broken_projection.sql.expected.ast.json
index 475b27c8c..71d4d3f3b 100644
--- a/tests/clickhouse-reference/03593_backup_with_broken_projection.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03593_backup_with_broken_projection.sql.expected.ast.json
@@ -239,7 +239,38 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "BACKUP TABLE 03593_backup_with_broken_projection TO Null SETTINGS allow_backup_broken_projections = true, check_projection_parts = false FORMAT Null"
+    "kind": "backup",
+    "operation": "BACKUP",
+    "elements": [
+      {
+        "kind": "table",
+        "table": {
+          "kind": "tableRef",
+          "table": "03593_backup_with_broken_projection"
+        }
+      }
+    ],
+    "destination": {
+      "name": "Null"
+    },
+    "settings": [
+      {
+        "name": "allow_backup_broken_projections",
+        "value": {
+          "kind": "literal",
+          "type": "Bool",
+          "value": "1"
+        }
+      },
+      {
+        "name": "check_projection_parts",
+        "value": {
+          "kind": "literal",
+          "type": "Bool",
+          "value": "0"
+        }
+      }
+    ],
+    "format": "Null"
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/03593_backup_with_broken_projection.sql.expected.formatted.sql b/tests/clickhouse-reference/03593_backup_with_broken_projection.sql.expected.formatted.sql
index 0739d6374..05d04624a 100644
--- a/tests/clickhouse-reference/03593_backup_with_broken_projection.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/03593_backup_with_broken_projection.sql.expected.formatted.sql
@@ -24,4 +24,4 @@ LIMIT 5000000;
 
 ALTER TABLE `03593_backup_with_broken_projection` (UPDATE _row_exists = 0 WHERE id = 0) SETTINGS mutations_sync = 1;
 
-BACKUP TABLE 03593_backup_with_broken_projection TO Null SETTINGS allow_backup_broken_projections = true, check_projection_parts = false FORMAT Null;
\ No newline at end of file
+BACKUP TABLE `03593_backup_with_broken_projection` TO Null SETTINGS allow_backup_broken_projections = true, check_projection_parts = false FORMAT Null;
\ No newline at end of file
diff --git a/tests/clickhouse-reference/03594_system_grants_parameters.sql.expected.ast.json b/tests/clickhouse-reference/03594_system_grants_parameters.sql.expected.ast.json
index b715e8ab8..d7b85a872 100644
--- a/tests/clickhouse-reference/03594_system_grants_parameters.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03594_system_grants_parameters.sql.expected.ast.json
@@ -27,28 +27,124 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "GRANT READ,WRITE ON S3 TO test_user_03593"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "READ"
+          },
+          {
+            "name": "WRITE"
+          }
+        ],
+        "target": {
+          "table": "S3"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_03593"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT READ,WRITE ON URL TO test_user_03593"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "READ"
+          },
+          {
+            "name": "WRITE"
+          }
+        ],
+        "target": {
+          "table": "URL"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_03593"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT READ ON POSTGRES TO test_user_03593"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "READ"
+          }
+        ],
+        "target": {
+          "table": "POSTGRES"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_03593"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT WRITE ON ODBC TO test_user_03593"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "WRITE"
+          }
+        ],
+        "target": {
+          "table": "ODBC"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_03593"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT SET DEFINER ON test_user_03593_1 TO test_user_03593"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "SET DEFINER"
+          }
+        ],
+        "target": {
+          "table": "test_user_03593_1"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_03593"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT TABLE ENGINE ON TinyLog TO test_user_03593"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "TABLE ENGINE"
+          }
+        ],
+        "target": {
+          "table": "TinyLog"
+        }
+      }
+    ],
+    "grantees": [
+      "test_user_03593"
+    ]
   },
   {
     "kind": "select",
diff --git a/tests/clickhouse-reference/03594_system_grants_parameters.sql.expected.formatted.sql b/tests/clickhouse-reference/03594_system_grants_parameters.sql.expected.formatted.sql
index e782a087d..e19da7745 100644
--- a/tests/clickhouse-reference/03594_system_grants_parameters.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/03594_system_grants_parameters.sql.expected.formatted.sql
@@ -7,9 +7,9 @@ CREATE USER test_user_03593;
 
 CREATE USER test_user_03593_1;
 
-GRANT READ,WRITE ON S3 TO test_user_03593;
+GRANT READ, WRITE ON S3 TO test_user_03593;
 
-GRANT READ,WRITE ON URL TO test_user_03593;
+GRANT READ, WRITE ON URL TO test_user_03593;
 
 GRANT READ ON POSTGRES TO test_user_03593;
 
diff --git a/tests/clickhouse-reference/03601_temporary_views.sql.expected.ast.json b/tests/clickhouse-reference/03601_temporary_views.sql.expected.ast.json
index a1f38f36f..68ef82dc5 100644
--- a/tests/clickhouse-reference/03601_temporary_views.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03601_temporary_views.sql.expected.ast.json
@@ -123,8 +123,16 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TEMPORARY VIEW tview_basic"
+    "kind": "show",
+    "show": {
+      "type": "objectShorthand",
+      "objectType": "VIEW",
+      "table": {
+        "kind": "tableRef",
+        "table": "tview_basic"
+      },
+      "temporary": true
+    }
   },
   {
     "kind": "createView",
diff --git a/tests/clickhouse-reference/03663_parameterized_views_formatting_of_substitutions_excessive_backticks.sql.expected.ast.json b/tests/clickhouse-reference/03663_parameterized_views_formatting_of_substitutions_excessive_backticks.sql.expected.ast.json
index c0580dd43..7747ec129 100644
--- a/tests/clickhouse-reference/03663_parameterized_views_formatting_of_substitutions_excessive_backticks.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03663_parameterized_views_formatting_of_substitutions_excessive_backticks.sql.expected.ast.json
@@ -209,8 +209,16 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW TABLE audit_size_column FORMAT Raw"
+    "kind": "show",
+    "show": {
+      "type": "objectShorthand",
+      "objectType": "TABLE",
+      "table": {
+        "kind": "tableRef",
+        "table": "audit_size_column"
+      }
+    },
+    "format": "Raw"
   },
   {
     "kind": "drop",
diff --git a/tests/clickhouse-reference/03714_queries_escaping_1.sql.expected.ast.json b/tests/clickhouse-reference/03714_queries_escaping_1.sql.expected.ast.json
index c06711cfb..5e3bfbbae 100644
--- a/tests/clickhouse-reference/03714_queries_escaping_1.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03714_queries_escaping_1.sql.expected.ast.json
@@ -1,9 +1,17 @@
 [
   {
-    "kind": "system",
-    "body": "show columns from a.b like 'a\\' or 1=1",
-    "trailingComments": [
-      "--'"
-    ]
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "database": "a",
+        "table": "b"
+      },
+      "like": {
+        "pattern": "a' or 1=1;--"
+      }
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/03714_queries_escaping_1.sql.expected.formatted.sql b/tests/clickhouse-reference/03714_queries_escaping_1.sql.expected.formatted.sql
index a375b00c1..12c2d026e 100644
--- a/tests/clickhouse-reference/03714_queries_escaping_1.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/03714_queries_escaping_1.sql.expected.formatted.sql
@@ -1 +1 @@
-show columns from a.b like 'a\' or 1=1; --'
\ No newline at end of file
+SHOW COLUMNS FROM a.b LIKE 'a\' or 1=1;--';
\ No newline at end of file
diff --git a/tests/clickhouse-reference/03714_queries_escaping_2.sql.expected.ast.json b/tests/clickhouse-reference/03714_queries_escaping_2.sql.expected.ast.json
index 5f133cf5b..62c4fdb6c 100644
--- a/tests/clickhouse-reference/03714_queries_escaping_2.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03714_queries_escaping_2.sql.expected.ast.json
@@ -1,9 +1,11 @@
 [
   {
-    "kind": "system",
-    "body": "show functions like 'a\\' or 1=1",
-    "trailingComments": [
-      "--'"
-    ]
+    "kind": "show",
+    "show": {
+      "type": "functions",
+      "like": {
+        "pattern": "a' or 1=1;--"
+      }
+    }
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/03714_queries_escaping_2.sql.expected.formatted.sql b/tests/clickhouse-reference/03714_queries_escaping_2.sql.expected.formatted.sql
index 27e2ae32a..63104f792 100644
--- a/tests/clickhouse-reference/03714_queries_escaping_2.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/03714_queries_escaping_2.sql.expected.formatted.sql
@@ -1 +1 @@
-show functions like 'a\' or 1=1; --'
\ No newline at end of file
+SHOW FUNCTIONS LIKE 'a\' or 1=1;--';
\ No newline at end of file
diff --git a/tests/clickhouse-reference/03721_parametrize_view_schema.sql.expected.ast.json b/tests/clickhouse-reference/03721_parametrize_view_schema.sql.expected.ast.json
index fda841817..b1493c970 100644
--- a/tests/clickhouse-reference/03721_parametrize_view_schema.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03721_parametrize_view_schema.sql.expected.ast.json
@@ -88,15 +88,29 @@
     }
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS IN 03271_parametrized_v",
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "03271_parametrized_v"
+      }
+    },
     "leadingComments": [
       "-- Should return no columns"
     ]
   },
   {
-    "kind": "system",
-    "body": "SHOW COLUMNS IN 03271_parametrized_v_expl",
+    "kind": "show",
+    "show": {
+      "type": "columns",
+      "keyword": "COLUMNS",
+      "table": {
+        "kind": "tableRef",
+        "table": "03271_parametrized_v_expl"
+      }
+    },
     "leadingComments": [
       "-- Should return one column 'n' of type 'UInt64'"
     ]
diff --git a/tests/clickhouse-reference/03721_parametrize_view_schema.sql.expected.formatted.sql b/tests/clickhouse-reference/03721_parametrize_view_schema.sql.expected.formatted.sql
index d6181f802..cc1a5053b 100644
--- a/tests/clickhouse-reference/03721_parametrize_view_schema.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/03721_parametrize_view_schema.sql.expected.formatted.sql
@@ -11,10 +11,10 @@ SELECT number AS n
 FROM numbers({upper_bound:UInt64});
 
 -- Should return no columns
-SHOW COLUMNS IN 03271_parametrized_v;
+SHOW COLUMNS FROM `03271_parametrized_v`;
 
 -- Should return one column 'n' of type 'UInt64'
-SHOW COLUMNS IN 03271_parametrized_v_expl;
+SHOW COLUMNS FROM `03271_parametrized_v_expl`;
 
 SELECT *
 FROM `system`.`columns`
diff --git a/tests/clickhouse-reference/03727_alter_with_localhost_remote.sql.expected.ast.json b/tests/clickhouse-reference/03727_alter_with_localhost_remote.sql.expected.ast.json
index 872479e88..3ceab5f9d 100644
--- a/tests/clickhouse-reference/03727_alter_with_localhost_remote.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03727_alter_with_localhost_remote.sql.expected.ast.json
@@ -102,16 +102,62 @@
     }
   },
   {
-    "kind": "system",
-    "body": "GRANT ALTER UPDATE ON normal TO test_03727"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "ALTER UPDATE"
+          }
+        ],
+        "target": {
+          "table": "normal"
+        }
+      }
+    ],
+    "grantees": [
+      "test_03727"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT READ ON REMOTE to test_03727"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "READ"
+          }
+        ],
+        "target": {
+          "table": "REMOTE"
+        }
+      }
+    ],
+    "grantees": [
+      "test_03727"
+    ]
   },
   {
-    "kind": "system",
-    "body": "GRANT CREATE TEMPORARY TABLE ON *.* TO test_03727"
+    "kind": "grant",
+    "operation": "GRANT",
+    "elements": [
+      {
+        "privileges": [
+          {
+            "name": "CREATE TEMPORARY TABLE"
+          }
+        ],
+        "target": {
+          "database": "*",
+          "table": "*"
+        }
+      }
+    ],
+    "grantees": [
+      "test_03727"
+    ]
   },
   {
     "kind": "executeAs",
diff --git a/tests/clickhouse-reference/03727_alter_with_localhost_remote.sql.expected.formatted.sql b/tests/clickhouse-reference/03727_alter_with_localhost_remote.sql.expected.formatted.sql
index 4d9cd52d9..d23ec3f13 100644
--- a/tests/clickhouse-reference/03727_alter_with_localhost_remote.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/03727_alter_with_localhost_remote.sql.expected.formatted.sql
@@ -24,7 +24,7 @@ INSERT INTO secret;
 
 GRANT ALTER UPDATE ON normal TO test_03727;
 
-GRANT READ ON REMOTE to test_03727;
+GRANT READ ON REMOTE TO test_03727;
 
 GRANT CREATE TEMPORARY TABLE ON *.* TO test_03727;
 
diff --git a/tests/clickhouse-reference/03760_backup_keepermap_memory.sql.expected.ast.json b/tests/clickhouse-reference/03760_backup_keepermap_memory.sql.expected.ast.json
index b824491db..1777fb597 100644
--- a/tests/clickhouse-reference/03760_backup_keepermap_memory.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03760_backup_keepermap_memory.sql.expected.ast.json
@@ -50,8 +50,21 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "BACKUP TABLE 03760_backup_memory TO Null FORMAT Null"
+    "kind": "backup",
+    "operation": "BACKUP",
+    "elements": [
+      {
+        "kind": "table",
+        "table": {
+          "kind": "tableRef",
+          "table": "03760_backup_memory"
+        }
+      }
+    ],
+    "destination": {
+      "name": "Null"
+    },
+    "format": "Null"
   },
   {
     "kind": "createTable",
@@ -122,7 +135,20 @@
     ]
   },
   {
-    "kind": "system",
-    "body": "BACKUP TABLE 03760_backup_keepermap TO Null FORMAT Null"
+    "kind": "backup",
+    "operation": "BACKUP",
+    "elements": [
+      {
+        "kind": "table",
+        "table": {
+          "kind": "tableRef",
+          "table": "03760_backup_keepermap"
+        }
+      }
+    ],
+    "destination": {
+      "name": "Null"
+    },
+    "format": "Null"
   }
 ]
\ No newline at end of file
diff --git a/tests/clickhouse-reference/03760_backup_keepermap_memory.sql.expected.formatted.sql b/tests/clickhouse-reference/03760_backup_keepermap_memory.sql.expected.formatted.sql
index 56a2ce1a8..1efbb4a78 100644
--- a/tests/clickhouse-reference/03760_backup_keepermap_memory.sql.expected.formatted.sql
+++ b/tests/clickhouse-reference/03760_backup_keepermap_memory.sql.expected.formatted.sql
@@ -8,7 +8,7 @@ ENGINE = Memory;
 
 INSERT INTO `03760_backup_memory` (c0);
 
-BACKUP TABLE 03760_backup_memory TO Null FORMAT Null;
+BACKUP TABLE `03760_backup_memory` TO Null FORMAT Null;
 
 CREATE TABLE `03760_backup_keepermap`
 (
@@ -19,4 +19,4 @@ PRIMARY KEY c0;
 
 INSERT INTO `03760_backup_keepermap` (c0);
 
-BACKUP TABLE 03760_backup_keepermap TO Null FORMAT Null;
\ No newline at end of file
+BACKUP TABLE `03760_backup_keepermap` TO Null FORMAT Null;
\ No newline at end of file
diff --git a/tests/clickhouse-reference/03760_backup_tar_archive.sql.expected.ast.json b/tests/clickhouse-reference/03760_backup_tar_archive.sql.expected.ast.json
index 3efdba60c..14a3f8dd0 100644
--- a/tests/clickhouse-reference/03760_backup_tar_archive.sql.expected.ast.json
+++ b/tests/clickhouse-reference/03760_backup_tar_archive.sql.expected.ast.json
@@ -129,12 +129,66 @@
     }
   },
   {
-    "kind": "system",
-    "body": "BACKUP TABLE t0 TO Disk('backups', '03760_backup_tar_archive.tar') FORMAT Null"
+    "kind": "backup",
+    "operation": "BACKUP",
+    "elements": [
+      {
+        "kind": "table",
+        "table": {
+          "kind": "tableRef",
+          "table": "t0"
+        }
+      }
+    ],
+    "destination": {
+      "name": "Disk",
+      "args": [
+        {
+          "kind": "literal",
+          "type": "String",
+          "value": "backups"
+        },
+        {
+          "kind": "literal",
+          "type": "String",
+          "value": "03760_backup_tar_archive.tar"
+        }
+      ]
+    },
+    "format": "Null"
   },
   {
-    "kind": "system",
-    "body": "RESTORE TABLE t0 AS t1 FROM Disk('backups', '03760_backup_tar_archive.tar') FORMAT Null"
+    "kind": "backup",
+    "operation": "RESTORE",
+    "elements": [
+      {
+        "kind": "table",
+        "table": {
+          "kind": "tableRef",
+          "table": "t0"
+        },
+        "as": {
+          "kind": "tableRef",
+          "table": "t1"
+        }
+      }
+    ],
+    "destination": {
+      "name": "Disk",
+      "args": [
+        {
+          "kind": "literal",
+          "type": "String",
+          "value": "backups"
+        },
+        {
+          "kind": "literal",
+          "type": "String",
+          "value": "03760_backup_tar_archive.tar"
+        }
+      ]
+    },
+    "format": "Null"
   },
   {
     "kind": "select",