Document

<SQL terminal character> ::=
  <SQL language character> 

<SQL language character> ::=
    <simple Latin letter> 
  | <digit> 
  | <SQL special character> 

<simple Latin letter> ::=
    <simple Latin upper case letter> 
  | <simple Latin lower case letter> 

<simple Latin upper case letter> ::=
    A | B | C | D | E | F | G | H | I | J | K | L | M | N | O
  | P | Q | R | S | T | U | V | W | X | Y | Z

<simple Latin lower case letter> ::=
    a | b | c | d | e | f | g | h | i | j | k | l | m | n | o
  | p | q | r | s | t | u | v | w | x | y | z

<digit> ::=
    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

<SQL special character> ::=
      <space> 
  |   <double quote> 
  |   <percent> 
  |   <ampersand> 
  |   <quote> 
  |   <left paren> 
  |   <right paren> 
  |   <asterisk> 
  |   <plus sign> 
  |   <comma> 
  |   <minus sign> 
  |   <period> 
  |   <solidus> 
  |   <colon> 
  |   <semicolon> 
  |   <less than operator> 
  |   <equals operator> 
  |   <greater than operator> 
  |   <question mark> 
  |   <left bracket> 
  |   <right bracket> 
  |   <circumflex> 
  |   <underscore> 
  |   <vertical bar> 
  |   <left brace> 
  |   <right brace> 
  |   <dollar sign> 
  |   <apostrophe> 

<space> ::=
  !! See the Syntax Rules.

<double quote> ::=
  "

<percent> ::=
  %

<ampersand> ::=
  &

<quote> ::=
  '

<left paren> ::=
  (

<right paren> ::=
  )

<asterisk> ::=
  *

<plus sign> ::=
  +

<comma> ::=
  ,

<minus sign> ::=
  -

<period> ::=
  .

<solidus> ::=
  /

<reverse solidus> ::=
  \

<colon> ::=
  :

<semicolon> ::=
  ;

<less than operator> ::=
  <

<equals operator> ::=
  =

<greater than operator> ::=
  >

<question mark> ::=
  ?

<left bracket or trigraph> ::=
    <left bracket> 
  | <left bracket trigraph> 

<right bracket or trigraph> ::=
    <right bracket> 
  | <right bracket trigraph> 

<left bracket> ::=
  [

<left bracket trigraph> ::=
  ??(

<right bracket> ::=
  ]

<right bracket trigraph> ::=
  ??)

<circumflex> ::=
  ^

<underscore> ::=
  _

<vertical bar> ::=
  |

<left brace> ::=
  {

<right brace> ::=
  }

<dollar sign> ::=
  $

<apostrophe> ::=
  '

<token> ::=
    <nondelimiter token> 
  | <delimiter token> 

<nondelimiter token> ::=
    <regular identifier> 
  | <key word> 
  | <unsigned numeric literal> 
  | <national character string literal> 
  | <binary string literal> 
  | <large object length token> 
  | <Unicode delimited identifier> 
  | <Unicode character string literal> 
  | <SQL language identifier> 

<regular identifier> ::=
  <identifier body> 

<identifier body> ::=
  <identifier start>  [ <identifier part> ... ]

<identifier part> ::=
    <identifier start> 
  | <identifier extend> 

<identifier start> ::=
  !! See the Syntax Rules.

<identifier extend> ::=
  !! See the Syntax Rules.

<large object length token> ::=
  <digit> ... <multiplier> 

<multiplier> ::=
    K
  | M
  | G
  | T
  | P

<delimited identifier> ::=
  <double quote>  <delimited identifier body>  <double quote> 

<delimited identifier body> ::=
  <delimited identifier part> ...

<delimited identifier part> ::=
    <nondoublequote character> 
  | <doublequote symbol> 

<Unicode delimited identifier> ::=
  U <ampersand>  <double quote>  <Unicode delimiter body>  <double quote> 
      <Unicode escape specifier> 

<Unicode escape specifier> ::=
  [ UESCAPE <quote>  <Unicode escape character>  <quote>  ]

<Unicode delimiter body> ::=
  <Unicode identifier part> ...

<Unicode identifier part> ::=
    <delimited identifier part> 
  | <Unicode escape value> 

<Unicode escape value> ::=
    <Unicode 4 digit escape value> 
  | <Unicode 6 digit escape value> 
  | <Unicode character escape value> 

<Unicode 4 digit escape value> ::=
  <Unicode escape character>  <hexit>  <hexit>  <hexit>  <hexit> 

<Unicode 6 digit escape value> ::=
  <Unicode escape character>  <plus sign> 
      <hexit>  <hexit>  <hexit>  <hexit>  <hexit>  <hexit> 

<Unicode character escape value> ::=
  <Unicode escape character>  <Unicode escape character> 

<Unicode escape character> ::=
  !! See the Syntax Rules.

<nondoublequote character> ::=
  !! See the Syntax Rules.

<doublequote symbol> ::=
  ""!! two consecutive double quote characters

<delimiter token> ::=
    <character string literal> 
  | <date string> 
  | <time string> 
  | <timestamp string> 
  | <interval string> 
  | <delimited identifier> 
  | <SQL special character> 
  | <not equals operator> 
  | <greater than or equals operator> 
  | <less than or equals operator> 
  | <concatenation operator> 
  | <right arrow> 
  | <left bracket trigraph> 
  | <right bracket trigraph> 
  | <double colon> 
  | <double period> 
  | <named argument assignment token> 
  | <left brace minus> 
  | <right minus brace> 

<not equals operator> ::=
  <<, <> >>

<greater than or equals operator> ::=
  >=

<less than or equals operator> ::=
  <=

<concatenation operator> ::=
  ||

<right arrow> ::=
  ->

<double colon> ::=
  ::

<double period> ::=
  ..

<named argument assignment token> ::=
  =>

<left brace minus> ::=
  {-

<right minus brace> ::=
  -}

<separator> ::=
  { <comment>  | <white space>  }...

<white space> ::=
  !! See the Syntax Rules.

<comment> ::=
    <simple comment> 
  | <bracketed comment> 

<simple comment> ::=
  <simple comment introducer>  [ <comment character> ... ] <newline> 

<simple comment introducer> ::=
  <minus sign>  <minus sign> 

<bracketed comment> ::=
  <bracketed comment introducer> 
      <bracketed comment contents> 
      <bracketed comment terminator> 

<bracketed comment introducer> ::=
  /*

<bracketed comment terminator> ::=
  */

<bracketed comment contents> ::=
  [ { <comment character>  | <separator>  }... ]!! See the Syntax Rules.

<comment character> ::=
    <nonquote character> 
  | <quote> 

<newline> ::=
  !! See the Syntax Rules.

<key word> ::=
    <reserved word> 
  | <non-reserved word> 

<non-reserved word> ::=
    A | ABSOLUTE | ACTION | ADA | ADD | ADMIN | AFTER | ALWAYS | ASC
  | ASSERTION | ASSIGNMENT | ATTRIBUTE | ATTRIBUTES

  | BEFORE | BERNOULLI | BREADTH

  | C | CASCADE | CATALOG | CATALOG_NAME | CHAIN | CHAINING | CHARACTER_SET_CATALOG
  | CHARACTER_SET_NAME | CHARACTER_SET_SCHEMA | CHARACTERISTICS | CHARACTERS
  | CLASS_ORIGIN | COBOL | COLLATION | COLLATION_CATALOG | COLLATION_NAME | COLLATION_SCHEMA
  | COLUMNS | COLUMN_NAME | COMMAND_FUNCTION | COMMAND_FUNCTION_CODE | COMMITTED
  | CONDITIONAL | CONDITION_NUMBER | CONNECTION | CONNECTION_NAME | CONSTRAINT_CATALOG
  | CONSTRAINT_NAME | CONSTRAINT_SCHEMA | CONSTRAINTS | CONSTRUCTOR
  | CONTINUE | CURSOR_NAME

  | DATA | DATETIME_INTERVAL_CODE | DATETIME_INTERVAL_PRECISION | DEFAULTS | DEFERRABLE
  | DEFERRED | DEFINED | DEFINER | DEGREE | DEPTH | DERIVED | DESC | DESCRIBE_CATALOG
  | DESCRIBE_NAME | DESCRIBE_PROCEDURE_SPECIFIC_CATALOG
  | DESCRIBE_PROCEDURE_SPECIFIC_NAME | DESCRIBE_PROCEDURE_SPECIFIC_SCHEMA
  | DESCRIBE_SCHEMA | DESCRIPTOR
  | DIAGNOSTICS | DISPATCH | DOMAIN | DYNAMIC_FUNCTION | DYNAMIC_FUNCTION_CODE

  | ENCODING | ENFORCED | ERROR | EXCLUDE | EXCLUDING | EXPRESSION

  | FINAL | FINISH | FINISH_CATALOG | FINISH_NAME | FINISH_PROCEDURE_SPECIFIC_CATALOG
  | FINISH_PROCEDURE_SPECIFIC_NAME | FINISH_PROCEDURE_SPECIFIC_SCHEMA
  | FINISH_SCHEMA | FIRST | FLAG | FOLLOWING | FORMAT | FORTRAN | FOUND | FULFILL
  | FULFILL_CATALOG | FULFILL_NAME | FULFILL_PROCEDURE_SPECIFIC_CATALOG
  | FULFILL_PROCEDURE_SPECIFIC_NAME | FULFILL_PROCEDURE_SPECIFIC_SCHEMA | FULFILL_SCHEMA

  | G | GENERAL | GENERATED | GO | GOTO | GRANTED

  | HAS_PASS_THROUGH_COLUMNS | HAS_PASS_THRU_COLS | HIERARCHY

  | IGNORE | IMMEDIATE | IMMEDIATELY | IMPLEMENTATION | INCLUDING | INCREMENT | INITIALLY
  | INPUT | INSTANCE | INSTANTIABLE | INSTEAD | INVOKER | ISOLATION | IS_PRUNABLE

  | JSON

  | K | KEEP | KEY | KEYS | KEY_MEMBER | KEY_TYPE

  | LAST | LENGTH | LEVEL | LOCATOR

  | M | MAP | MATCHED | MAXVALUE | MESSAGE_LENGTH | MESSAGE_OCTET_LENGTH
  | MESSAGE_TEXT | MINVALUE | MORE | MUMPS

  | NAME | NAMES | NESTED | NESTING | NEXT | NFC | NFD | NFKC | NFKD
  | NORMALIZED | NULLABLE | NULLS | NUMBER

  | OBJECT | OCTETS | OPTION | OPTIONS | ORDERING | ORDINALITY | OTHERS
  | OUTPUT | OVERFLOW | OVERRIDING

  | P | PAD | PARAMETER_MODE | PARAMETER_NAME | PARAMETER_ORDINAL_POSITION
  | PARAMETER_SPECIFIC_CATALOG | PARAMETER_SPECIFIC_NAME | PARAMETER_SPECIFIC_SCHEMA
  | PARTIAL | PASCAL | PASS | PASSING | PAST | PATH | PLACING | PLAN | PLI
  | PRECEDING | PRESERVE | PRIOR | PRIVATE | PRIVATE_PARAMETERS | PRIVATE_PARAMS_S
  | PRIVILEGES | PRUNE | PUBLIC

  | QUOTES

  | READ | RELATIVE | REPEATABLE | RESPECT | RESTART | RESTRICT | RETURNED_CARDINALITY
  | RETURNED_LENGTH | RETURNED_OCTET_LENGTH | RETURNED_SQLSTATE | RETURNING
  | RETURNS_ONLY_PASS_THROUGH | RET_ONLY_PASS_THRU | ROLE | ROUTINE
  | ROUTINE_CATALOG | ROUTINE_NAME | ROUTINE_SCHEMA | ROW_COUNT

  | SCALAR | SCALE | SCHEMA | SCHEMA_NAME | SCOPE_CATALOG | SCOPE_NAME
  | SCOPE_SCHEMA | SECTION | SECURITY | SELF | SEQUENCE | SERIALIZABLE | SERVER_NAME
  | SESSION | SETS | SIMPLE | SIZE | SOURCE | SPACE | SPECIFIC_NAME | START_CATALOG
  | START_NAME | START_PROCEDURE_SPECIFIC_CATALOG | START_PROCEDURE_SPECIFIC_NAME
  | START_PROCEDURE_SPECIFIC_SCHEMA | START_SCHEMA | STATE | STATEMENT
  | STRING | STRUCTURE | STYLE | SUBCLASS_ORIGIN

  | T | TABLE_NAME | TABLE_SEMANTICS | TEMPORARY | THROUGH | TIES | TOP_LEVEL_COUNT
  | TRANSACTION | TRANSACTION_ACTIVE | TRANSACTIONS_COMMITTED
  | TRANSACTIONS_ROLLED_BACK | TRANSFORM | TRANSFORMS | TRIGGER_CATALOG | TRIGGER_NAME
  | TRIGGER_SCHEMA | TYPE

  | UNBOUNDED | UNCOMMITTED | UNCONDITIONAL | UNDER | UNNAMED | USAGE
  | USER_DEFINED_TYPE_CATALOG | USER_DEFINED_TYPE_CODE | USER_DEFINED_TYPE_NAME
  | USER_DEFINED_TYPE_SCHEMA | UTF16 | UTF32 | UTF8

  | VIEW

  | WORK | WRAPPER | WRITE

  | ZONE

<reserved word> ::=
    ABS | ACOS | ALL | ALLOCATE | ALTER | AND | ANY | ARE | ARRAY | ARRAY_AGG
  | ARRAY_MAX_CARDINALITY | AS | ASENSITIVE | ASIN | ASYMMETRIC | AT | ATAN
  | ATOMIC | AUTHORIZATION | AVG

  | BEGIN | BEGIN_FRAME | BEGIN_PARTITION | BETWEEN | BIGINT | BINARY
  | BLOB | BOOLEAN | BOTH | BY

  | CALL | CALLED | CARDINALITY | CASCADED | CASE | CAST | CEIL | CEILING
  | CHAR | CHAR_LENGTH | CHARACTER | CHARACTER_LENGTH | CHECK | CLASSIFIER | CLOB
  | CLOSE | COALESCE | COLLATE | COLLECT | COLUMN | COMMIT | CONDITION | CONNECT
  | CONSTRAINT | CONTAINS | CONVERT | COPY | CORR | CORRESPONDING | COS | COSH
  | COUNT | COVAR_POP | COVAR_SAMP | CREATE | CROSS | CUBE | CUME_DIST | CURRENT
  | CURRENT_CATALOG | CURRENT_DATE | CURRENT_DEFAULT_TRANSFORM_GROUP
  | CURRENT_PATH | CURRENT_ROLE | CURRENT_ROW | CURRENT_SCHEMA | CURRENT_TIME
  | CURRENT_TIMESTAMP | CURRENT_PATH | CURRENT_ROLE | CURRENT_TRANSFORM_GROUP_FOR_TYPE
  | CURRENT_USER | CURSOR | CYCLE

  | DATE | DAY | DEALLOCATE | DEC | DECIMAL | DECFLOAT | DECLARE | DEFAULT | DEFINE
  | DELETE | DENSE_RANK | DEREF | DESCRIBE | DETERMINISTIC | DISCONNECT | DISTINCT
  | DOUBLE | DROP | DYNAMIC

  | EACH | ELEMENT | ELSE | EMPTY | END | END_FRAME | END_PARTITION | END-EXEC
  | EQUALS | ESCAPE | EVERY | EXCEPT | EXEC | EXECUTE | EXISTS | EXP
  | EXTERNAL | EXTRACT

  | FALSE | FETCH | FILTER | FIRST_VALUE | FLOAT | FLOOR | FOR | FOREIGN
  | FRAME_ROW | FREE | FROM | FULL | FUNCTION | FUSION

  | GET | GLOBAL | GRANT | GROUP | GROUPING | GROUPS

  | HAVING | HOLD | HOUR

  | IDENTITY | IN | INDICATOR | INITIAL | INNER | INOUT | INSENSITIVE | INSERT
  | INT | INTEGER | INTERSECT | INTERSECTION | INTERVAL | INTO | IS

  | JOIN | JSON_ARRAY | JSON_ARRAYAGG | JSON_EXISTS | JSON_OBJECT
  | JSON_OBJECTAGG | JSON_QUERY | JSON_TABLE | JSON_TABLE_PRIMITIVE | JSON_VALUE

  | LAG | LANGUAGE | LARGE | LAST_VALUE | LATERAL | LEAD | LEADING | LEFT | LIKE
  | LIKE_REGEX | LISTAGG | LN | LOCAL | LOCALTIME | LOCALTIMESTAMP | LOG | LOG10 | LOWER

  | MATCH | MATCH_NUMBER | MATCH_RECOGNIZE | MATCHES | MAX | MEMBER
  | MERGE | METHOD | MIN | MINUTE | MOD | MODIFIES | MODULE | MONTH | MULTISET

  | NATIONAL | NATURAL | NCHAR | NCLOB | NEW | NO | NONE | NORMALIZE | NOT
  | NTH_VALUE | NTILE | NULL | NULLIF | NUMERIC

  | OCTET_LENGTH | OCCURRENCES_REGEX | OF | OFFSET | OLD | OMIT | ON | ONE
  | ONLY | OPEN | OR | ORDER | OUT | OUTER | OVER | OVERLAPS | OVERLAY

  | PARAMETER | PARTITION | PATTERN | PER | PERCENT | PERCENT_RANK
  | PERCENTILE_CONT | PERCENTILE_DISC | PERIOD | PORTION | POSITION | POSITION_REGEX
  | POWER | PRECEDES | PRECISION | PREPARE | PRIMARY | PROCEDURE | PTF

  | RANGE | RANK | READS | REAL | RECURSIVE | REF | REFERENCES | REFERENCING
  | REGR_AVGX | REGR_AVGY | REGR_COUNT | REGR_INTERCEPT | REGR_R2 | REGR_SLOPE
  | REGR_SXX | REGR_SXY | REGR_SYY | RELEASE | RESULT | RETURN | RETURNS
  | REVOKE | RIGHT | ROLLBACK | ROLLUP | ROW | ROW_NUMBER | ROWS | RUNNING

  | SAVEPOINT | SCOPE | SCROLL | SEARCH | SECOND | SEEK | SELECT | SENSITIVE
  | SESSION_USER | SET | SHOW | SIMILAR | SIN | SINH | SKIP | SMALLINT | SOME | SPECIFIC
  | SPECIFICTYPE | SQL | SQLEXCEPTION | SQLSTATE | SQLWARNING | SQRT | START
  | STATIC | STDDEV_POP | STDDEV_SAMP | SUBMULTISET | SUBSET | SUBSTRING
  | SUBSTRING_REGEX | SUCCEEDS | SUM | SYMMETRIC | SYSTEM | SYSTEM_TIME
  | SYSTEM_USER

  | TABLE | TABLESAMPLE | TAN | TANH | THEN | TIME | TIMESTAMP | TIMEZONE_HOUR
  | TIMEZONE_MINUTE | TO | TRAILING | TRANSLATE | TRANSLATE_REGEX | TRANSLATION | TREAT
  | TRIGGER | TRIM | TRIM_ARRAY | TRUE | TRUNCATE

  | UESCAPE | UNION | UNIQUE | UNKNOWN | UNNEST | UPDATE    | UPPER | USER | USING

  | VALUE | VALUES | VALUE_OF | VAR_POP | VAR_SAMP | VARBINARY
  | VARCHAR | VARYING | VERSIONING

  | WHEN | WHENEVER | WHERE | WIDTH_BUCKET | WINDOW | WITH | WITHIN | WITHOUT

  | YEAR

<literal> ::=
    <signed numeric literal> 
  | <general literal> 

<unsigned literal> ::=
    <unsigned numeric literal> 
  | <general literal> 

<general literal> ::=
    <character string literal> 
  | <national character string literal> 
  | <Unicode character string literal> 
  | <binary string literal> 
  | <datetime literal> 
  | <interval literal> 
  | <boolean literal> 

<character string literal> ::=
  [ <introducer>  <character set specification>  ]
      <quote>  [ <character representation> ... ] <quote> 
      [ { <separator>  <quote>  [ <character representation> ... ] <quote>  }... ]

<introducer> ::=
  <underscore> 

<character representation> ::=
    <nonquote character> 
  | <quote symbol> 

<nonquote character> ::=
  !! See the Syntax Rules.

<quote symbol> ::=
  <quote>  <quote> 

<national character string literal> ::=
  N <quote>  [ <character representation> ... ]
      <quote>  [ { <separator>  <quote>  [ <character representation> ... ] <quote>  }... ]

<Unicode character string literal> ::=
  [ <introducer>  <character set specification>  ]
      U <ampersand>  <quote>  [ <Unicode representation> ... ] <quote> 
      [ { <separator>  <quote>  [ <Unicode representation> ... ] <quote>  }... ]
      <Unicode escape specifier> 

<Unicode representation> ::=
    <character representation> 
  | <Unicode escape value> 

<binary string literal> ::=
  X <quote>  [ <space> ... ] [ { <hexit>  [ <space> ... ] <hexit>  [ <space> ... ] }... ] <quote> 
      [ { <separator>  <quote>  [ <space> ... ] [ { <hexit>  [ <space> ... ]
      <hexit>  [ <space> ... ] }... ] <quote>  }... ]

<hexit> ::=
    <digit>  | A | B | C | D | E | F | a | b | c | d | e | f

<signed numeric literal> ::=
  [ <sign>  ] <unsigned numeric literal> 

<unsigned numeric literal> ::=
    <exact numeric literal> 
  | <approximate numeric literal> 

<exact numeric literal> ::=
    <unsigned integer>  [ <period>  [ <unsigned integer>  ] ]
  | <period>  <unsigned integer> 

<sign> ::=
    <plus sign> 
  | <minus sign> 

<approximate numeric literal> ::=
  <mantissa>  E <exponent> 

<mantissa> ::=
  <exact numeric literal> 

<exponent> ::=
  <signed integer> 

<signed integer> ::=
  [ <sign>  ] <unsigned integer> 

<unsigned integer> ::=
  <digit> ...

<datetime literal> ::=
    <date literal> 
  | <time literal> 
  | <timestamp literal> 

<date literal> ::=
  DATE <date string> 

<time literal> ::=
  TIME <time string> 

<timestamp literal> ::=
  TIMESTAMP <timestamp string> 

<date string> ::=
  <quote>  <unquoted date string>  <quote> 

<time string> ::=
  <quote>  <unquoted time string>  <quote> 

<timestamp string> ::=
  <quote>  <unquoted timestamp string>  <quote> 

<time zone interval> ::=
  <sign>  <hours value>  <colon>  <minutes value> 

<date value> ::=
  <years value>  <minus sign>  <months value>  <minus sign>  <days value> 

<time value> ::=
  <hours value>  <colon>  <minutes value>  <colon>  <seconds value> 

<interval literal> ::=
  INTERVAL [ <sign>  ] <interval string>  <interval qualifier> 

<interval string> ::=
  <quote>  <unquoted interval string>  <quote> 

<unquoted date string> ::=
  <date value> 

<unquoted time string> ::=
  <time value>  [ <time zone interval>  ]

<unquoted timestamp string> ::=
  <unquoted date string>  <space>  <unquoted time string> 

<unquoted interval string> ::=
  [ <sign>  ] { <year-month literal>  | <day-time literal>  }

<year-month literal> ::=
    <years value>  [ <minus sign>  <months value>  ]
  | <months value> 

<day-time literal> ::=
    <day-time interval> 
  | <time interval> 

<day-time interval> ::=
  <days value>  [ <space>  <hours value>  [ <colon>  <minutes value> 
      [ <colon>  <seconds value>  ] ] ]

<time interval> ::=
    <hours value>  [ <colon>  <minutes value>  [ <colon>  <seconds value>  ] ]
  | <minutes value>  [ <colon>  <seconds value>  ]
  | <seconds value> 

<years value> ::=
  <datetime value> 

<months value> ::=
  <datetime value> 

<days value> ::=
  <datetime value> 

<hours value> ::=
  <datetime value> 

<minutes value> ::=
  <datetime value> 

<seconds value> ::=
  <seconds integer value>  [ <period>  [ <seconds fraction>  ] ]

<seconds integer value> ::=
  <unsigned integer> 

<seconds fraction> ::=
  <unsigned integer> 

<datetime value> ::=
  <unsigned integer> 

<boolean literal> ::=
    TRUE
  | FALSE
  | UNKNOWN

<identifier> ::=
  <actual identifier> 

<actual identifier> ::=
    <regular identifier> 
  | <delimited identifier> 
  | <Unicode delimited identifier> 

<SQL language identifier> ::=
  <SQL language identifier start>  [ <SQL language identifier part> ... ]

<SQL language identifier start> ::=
  <simple Latin letter> 

<SQL language identifier part> ::=
    <simple Latin letter> 
  | <digit> 
  | <underscore> 

<authorization identifier> ::=
    <role name> 
  | <user identifier> 

<table name> ::=
  <local or schema qualified name> 

<domain name> ::=
  <schema qualified name> 

<schema name> ::=
  [ <catalog name>  <period>  ] <unqualified schema name> 

<unqualified schema name> ::=
  <identifier> 

<catalog name> ::=
  <identifier> 

<schema qualified name> ::=
  [ <schema name>  <period>  ] <qualified identifier> 

<local or schema qualified name> ::=
  [ <local or schema qualifier>  <period>  ] <qualified identifier> 

<local or schema qualifier> ::=
    <schema name> 
  | <local qualifier> 

<qualified identifier> ::=
  <identifier> 

<column name> ::=
  <identifier> 

<correlation name> ::=
  <identifier> 

<query name> ::=
  <identifier> 

<SQL-client module name> ::=
  <identifier> 

<procedure name> ::=
  <identifier> 

<schema qualified routine name> ::=
  <schema qualified name> 

<method name> ::=
  <identifier> 

<specific name> ::=
  <schema qualified name> 

<cursor name> ::=
  <local qualified name> 

<local qualified name> ::=
  [ <local qualifier>  <period>  ] <qualified identifier> 

<local qualifier> ::=
  MODULE

<host parameter name> ::=
  <colon>  <identifier> 

<SQL parameter name> ::=
  <identifier> 

<constraint name> ::=
  <schema qualified name> 

<external routine name> ::=
    <identifier> 
  | <character string literal> 

<trigger name> ::=
  <schema qualified name> 

<collation name> ::=
  <schema qualified name> 

<character set name> ::=
  [ <schema name>  <period>  ] <SQL language identifier> 

<transliteration name> ::=
  <schema qualified name> 

<transcoding name> ::=
  <schema qualified name> 

<schema-resolved user-defined type name> ::=
  <user-defined type name> 

<user-defined type name> ::=
  [ <schema name>  <period>  ] <qualified identifier> 

<attribute name> ::=
  <identifier> 

<field name> ::=
  <identifier> 

<savepoint name> ::=
  <identifier> 

<sequence generator name> ::=
  <schema qualified name> 

<role name> ::=
  <identifier> 

<user identifier> ::=
  <identifier> 

<connection name> ::=
  <simple value specification> 

<SQL-server name> ::=
  <simple value specification> 

<connection user name> ::=
  <simple value specification> 

<SQL statement name> ::=
    <statement name> 
  | <extended statement name> 

<statement name> ::=
  <identifier> 

<extended statement name> ::=
  [ <scope option>  ] <simple value specification> 

<dynamic cursor name> ::=
    <conventional dynamic cursor name> 
  | <PTF cursor name> 

<conventional dynamic cursor name> ::=
    <cursor name> 
  | <extended cursor name> 

<extended cursor name> ::=
  [ <scope option>  ] <simple value specification> 

<PTF cursor name> ::=
  PTF <simple value specification> 

<descriptor name> ::=
    <conventional descriptor name> 
  | <PTF descriptor name> 

<conventional descriptor name> ::=
    <non-extended descriptor name> 
  | <extended descriptor name> 

<non-extended descriptor name> ::=
  <identifier> 

<extended descriptor name> ::=
  [ <scope option>  ] <simple value specification> 

<scope option> ::=
    GLOBAL
  | LOCAL

<PTF descriptor name> ::=
  PTF <simple value specification> 

<window name> ::=
  <identifier> 

<row pattern variable name> ::=
  <correlation name> 

<measure name> ::=
  <identifier> 

<data type> ::=
    <predefined type> 
  | <row type> 
  | <path-resolved user-defined type name> 
  | <reference type> 
  | <collection type> 

<predefined type> ::=
      <character string type>  [ CHARACTER SET <character set specification>  ]
          [ <collate clause>  ]
  |   <national character string type>  [ <collate clause>  ]
  |   <binary string type> 
  |   <numeric type> 
  |   <boolean type> 
  |   <datetime type> 
  |   <interval type> 

<character string type> ::=
    CHARACTER [ <left paren>  <character length>  <right paren>  ]
  | CHAR [ <left paren>  <character length>  <right paren>  ]
  | CHARACTER VARYING <left paren>  <character length>  <right paren> 
  | CHAR VARYING <left paren>  <character length>  <right paren> 
  | VARCHAR <left paren>  <character length>  <right paren> 
  | <character large object type> 

<character large object type> ::=
    CHARACTER LARGE OBJECT [ <left paren>  <character large object length>  <right paren>  ]
  | CHAR LARGE OBJECT [ <left paren>  <character large object length>  <right paren>  ]
  | CLOB [ <left paren>  <character large object length>  <right paren>  ]

<national character string type> ::=
    NATIONAL CHARACTER [ <left paren>  <character length>  <right paren>  ]
  | NATIONAL CHAR [ <left paren>  <character length>  <right paren>  ]
  | NCHAR [ <left paren>  <character length>  <right paren>  ]
  | NATIONAL CHARACTER VARYING <left paren>  <character length>  <right paren> 
  | NATIONAL CHAR VARYING <left paren>  <character length>  <right paren> 
  | NCHAR VARYING <left paren>  <character length>  <right paren> 
  | <national character large object type> 

<national character large object type> ::=
    NATIONAL CHARACTER LARGE OBJECT [ <left paren>  <character large object length>  <right paren>  ]
  | NCHAR LARGE OBJECT [ <left paren>  <character large object length>  <right paren>  ]
  | NCLOB [ <left paren>  <character large object length>  <right paren>  ]

<binary string type> ::=
    BINARY [ <left paren>  <length>  <right paren>  ]
  | BINARY VARYING <left paren>  <length>  <right paren> 
  | VARBINARY <left paren>  <length>  <right paren> 
  | <binary large object string type> 

<binary large object string type> ::=
    BINARY LARGE OBJECT [ <left paren>  <large object length>  <right paren>  ]
  | BLOB [ <left paren>  <large object length>  <right paren>  ]

<numeric type> ::=
    <exact numeric type> 
  | <approximate numeric type> 
  | <decimal floating-point type> 

<exact numeric type> ::=
    NUMERIC [ <left paren>  <precision>  [ <comma>  <scale>  ] <right paren>  ]
  | DECIMAL [ <left paren>  <precision>  [ <comma>  <scale>  ] <right paren>  ]
  | DEC [ <left paren>  <precision>  [ <comma>  <scale>  ] <right paren>  ]
  | SMALLINT
  | INTEGER
  | INT
  | BIGINT

<approximate numeric type> ::=
    FLOAT [ <left paren>  <precision>  <right paren>  ]
  | REAL
  | DOUBLE PRECISION

<decimal floating-point type> ::=
  DECFLOAT [ <left paren>  <precision>  <right paren>  ]

<length> ::=
  <unsigned integer> 

<character length> ::=
  <length>  [ <char length units>  ]

<large object length> ::=
    <unsigned integer>  [ <multiplier>  ]
  | <large object length token> 

<character large object length> ::=
  <large object length>  [ <char length units>  ]

<char length units> ::=
    CHARACTERS
  | OCTETS

<precision> ::=
  <unsigned integer> 

<scale> ::=
  <unsigned integer> 

<boolean type> ::=
  BOOLEAN

<datetime type> ::=
    DATE
  | TIME [ <left paren>  <time precision>  <right paren>  ] [ <with or without time zone>  ]
  | TIMESTAMP [ <left paren>  <timestamp precision>  <right paren>  ]
      [ <with or without time zone>  ]

<with or without time zone> ::=
    WITH TIME ZONE
  | WITHOUT TIME ZONE

<time precision> ::=
  <time fractional seconds precision> 

<timestamp precision> ::=
  <time fractional seconds precision> 

<time fractional seconds precision> ::=
  <unsigned integer> 

<interval type> ::=
  INTERVAL <interval qualifier> 

<row type> ::=
  ROW <row type body> 

<row type body> ::=
  <left paren>  <field definition>  [ { <comma>  <field definition>  }... ] <right paren> 

<reference type> ::=
  REF <left paren>  <referenced type>  <right paren>  [ <scope clause>  ]

<scope clause> ::=
  SCOPE <table name> 

<referenced type> ::=
  <path-resolved user-defined type name> 

<path-resolved user-defined type name> ::=
  <user-defined type name> 

<collection type> ::=
    <array type> 
  | <multiset type> 

<array type> ::=
  <data type>  ARRAY
      [ <left bracket or trigraph>  <maximum cardinality>  <right bracket or trigraph>  ]

<maximum cardinality> ::=
  <unsigned integer> 

<multiset type> ::=
  <data type>  MULTISET

<field definition> ::=
  <field name>  <data type> 

<value expression primary> ::=
    <parenthesized value expression> 
  | <nonparenthesized value expression primary> 

<parenthesized value expression> ::=
  <left paren>  <value expression>  <right paren> 

<nonparenthesized value expression primary> ::=
       <unsigned value specification> 
     | <column reference> 
     | <set function specification> 
     | <window function> 
     | <nested window function> 
     | <scalar subquery> 
     | <case expression> 
     | <cast specification> 
     | <field reference> 
     | <subtype treatment> 
     | <method invocation> 
     | <static method invocation> 
     | <new specification> 
     | <attribute or method reference> 
     | <reference resolution> 
     | <collection value constructor> 
     | <array element reference> 
     | <multiset element reference> 
     | <next value expression> 
     | <routine invocation> 
     | <row pattern navigation operation> 
     | <JSON value function> 

<collection value constructor> ::=
    <array value constructor> 
  | <multiset value constructor> 

<value specification> ::=
    <literal> 
  | <general value specification> 

<unsigned value specification> ::=
    <unsigned literal> 
  | <general value specification> 

<general value specification> ::=
    <host parameter specification> 
  | <SQL parameter reference> 
  | <dynamic parameter specification> 
  | <embedded variable specification> 
  | <current collation specification> 
  | CURRENT_CATALOG
  | CURRENT_DEFAULT_TRANSFORM_GROUP
  | CURRENT_PATH
  | CURRENT_ROLE
  | CURRENT_SCHEMA
  | CURRENT_TRANSFORM_GROUP_FOR_TYPE <path-resolved user-defined type name> 
  | CURRENT_USER
  | SESSION_USER
  | SYSTEM_USER
  | USER
  | VALUE

<simple value specification> ::=
    <literal> 
  | <host parameter name> 
  | <SQL parameter reference> 
  | <embedded variable name> 

<target specification> ::=
    <host parameter specification> 
  | <SQL parameter reference> 
  | <column reference> 
  | <target array element specification> 
  | <dynamic parameter specification> 
  | <embedded variable specification> 

<simple target specification> ::=
    <host parameter name> 
  | <SQL parameter reference> 
  | <column reference> 
  | <embedded variable name> 

<host parameter specification> ::=
  <host parameter name>  [ <indicator parameter>  ]

<dynamic parameter specification> ::=
  <question mark> 

<embedded variable specification> ::=
  <embedded variable name>  [ <indicator variable>  ]

<indicator variable> ::=
  [ INDICATOR ] <embedded variable name> 

<indicator parameter> ::=
  [ INDICATOR ] <host parameter name> 

<target array element specification> ::=
  <target array reference> 
      <left bracket or trigraph>  <simple value specification>  <right bracket or trigraph> 

<target array reference> ::=
    <SQL parameter reference> 
  | <column reference> 

<current collation specification> ::=
  COLLATION FOR <left paren>  <string value expression>  <right paren> 

<contextually typed value specification> ::=
    <implicitly typed value specification> 
  | <default specification> 

<implicitly typed value specification> ::=
    <null specification> 
  | <empty specification> 

<null specification> ::=
  NULL

<empty specification> ::=
    ARRAY <left bracket or trigraph>  <right bracket or trigraph> 
  | MULTISET <left bracket or trigraph>  <right bracket or trigraph> 

<default specification> ::=
  DEFAULT

<identifier chain> ::=
  <identifier>  [ { <period>  <identifier>  }... ]

<basic identifier chain> ::=
  <identifier chain> 

<column reference> ::=
    <basic identifier chain> 
  | MODULE <period>  <qualified identifier>  <period>  <column name> 

<SQL parameter reference> ::=
  <basic identifier chain> 

<set function specification> ::=
    [ <running or final>  ] <aggregate function> 
  | <grouping operation> 

<running or final> ::=
  RUNNING | FINAL

<grouping operation> ::=
  GROUPING <left paren>  <column reference> 
      [ { <comma>  <column reference>  }... ] <right paren> 

<window function> ::=
  <window function type>  OVER <window name or specification> 

<window function type> ::=
    <rank function type>  <left paren>  <right paren> 
  | ROW_NUMBER <left paren>  <right paren> 
  | <aggregate function> 
  | <ntile function> 
  | <lead or lag function> 
  | <first or last value function> 
  | <nth value function> 
  | <window row pattern measure> 

<rank function type> ::=
    RANK
  | DENSE_RANK
  | PERCENT_RANK
  | CUME_DIST

<ntile function> ::=
  NTILE <left paren>  <number of tiles>  <right paren> 

<number of tiles> ::=
    <simple value specification> 
  | <dynamic parameter specification> 

<lead or lag function> ::=
  <lead or lag>  <left paren>  <lead or lag extent> 
      [ <comma>  <offset>  [ <comma>  <default expression>  ] ] <right paren> 
      [ <null treatment>  ]

<lead or lag> ::=
  LEAD | LAG

<lead or lag extent> ::=
  <value expression> 

<offset> ::=
  <exact numeric literal> 

<default expression> ::=
  <value expression> 

<null treatment> ::=
  RESPECT NULLS | IGNORE NULLS

<first or last value function> ::=
  <first or last value>  <left paren>  <value expression>  <right paren>  [ <null treatment> 
  ]

<first or last value> ::=
  FIRST_VALUE | LAST_VALUE

<nth value function> ::=
  NTH_VALUE <left paren>  <value expression>  <comma>  <nth row>  <right paren> 
      [ <from first or last>  ] [ <null treatment>  ]

<nth row> ::=
    <simple value specification> 
  | <dynamic parameter specification> 

<from first or last> ::=
    FROM FIRST
  | FROM LAST

<window name or specification> ::=
    <window name> 
  | <in-line window specification> 

<in-line window specification> ::=
  <window specification> 

<window row pattern measure> ::=
  <measure name> 

<nested window function> ::=
    <nested row number function> 
  | <value_of expression at row> 

<nested row number function> ::=
  ROW_NUMBER <left paren>  <row marker>  <right paren> 

<value_of expression at row> ::=
  VALUE_OF <left paren>  <value expression>  AT <row marker expression> 
      [ <comma>  <value_of default value>  ] <right paren> 

<row marker> ::=
    BEGIN_PARTITION
  | BEGIN_FRAME
  | CURRENT_ROW
  | FRAME_ROW
  | END_FRAME
  | END_PARTITION

<row marker expression> ::=
  <row marker>  [ <row marker delta>  ]

<row marker delta> ::=
    <plus sign>  <row marker offset> 
  | <minus sign>  <row marker offset> 

<row marker offset> ::=
    <simple value specification> 
  | <dynamic parameter specification> 

<value_of default value> ::=
  <value expression> 

<case expression> ::=
    <case abbreviation> 
  | <case specification> 

<case abbreviation> ::=
    NULLIF <left paren>  <value expression>  <comma>  <value expression>  <right paren> 
  | COALESCE <left paren>  <value expression> 
      { <comma>  <value expression>  }... <right paren> 

<case specification> ::=
    <simple case> 
  | <searched case> 

<simple case> ::=
  CASE <case operand>  <simple when clause> ... [ <else clause>  ] END

<searched case> ::=
  CASE <searched when clause> ... [ <else clause>  ] END

<simple when clause> ::=
  WHEN <when operand list>  THEN <result> 

<searched when clause> ::=
  WHEN <search condition>  THEN <result> 

<else clause> ::=
  ELSE <result> 

<case operand> ::=
    <row value predicand> 
  | <overlaps predicate part 1> 

<when operand list> ::=
  <when operand>  [ { <comma>  <when operand>  }... ]

<when operand> ::=
    <row value predicand> 
  | <comparison predicate part 2> 
  | <between predicate part 2> 
  | <in predicate part 2> 
  | <character like predicate part 2> 
  | <octet like predicate part 2> 
  | <similar predicate part 2> 
  | <regex like predicate part 2> 
  | <null predicate part 2> 
  | <quantified comparison predicate part 2> 
  | <normalized predicate part 2> 
  | <match predicate part 2> 
  | <overlaps predicate part 2> 
  | <distinct predicate part 2> 
  | <member predicate part 2> 
  | <submultiset predicate part 2> 
  | <set predicate part 2> 
  | <type predicate part 2> 

<result> ::=
    <result expression> 
  | NULL

<result expression> ::=
  <value expression> 

<cast specification> ::=
     CAST <left paren> 
         <cast operand>  AS <cast target> 
         [ FORMAT <cast template>  ]
         <right paren> 

<cast operand> ::=
    <value expression> 
  | <implicitly typed value specification> 

<cast target> ::=
    <domain name> 
  | <data type> 

<cast template> ::=
  <character string literal> 

<next value expression> ::=
  NEXT VALUE FOR <sequence generator name> 

<field reference> ::=
  <value expression primary>  <period>  <field name> 

<subtype treatment> ::=
  TREAT <left paren>  <subtype operand>  AS <target subtype>  <right paren> 

<subtype operand> ::=
  <value expression> 

<target subtype> ::=
    <path-resolved user-defined type name> 
  | <reference type> 

<method invocation> ::=
    <direct invocation> 
  | <generalized invocation> 

<direct invocation> ::=
  <value expression primary>  <period>  <method name>  [ <SQL argument list>  ]

<generalized invocation> ::=
  <left paren>  <value expression primary>  AS <data type>  <right paren> 
      <period>  <method name>  [ <SQL argument list>  ]

<method selection> ::=
  <routine invocation> 

<constructor method selection> ::=
  <routine invocation> 

<static method invocation> ::=
  <path-resolved user-defined type name>  <double colon>  <method name> 
      [ <SQL argument list>  ]

<static method selection> ::=
  <routine invocation> 

<new specification> ::=
  NEW <path-resolved user-defined type name>  <SQL argument list> 

<new invocation> ::=
    <method invocation> 
  | <routine invocation> 

<attribute or method reference> ::=
  <value expression primary>  <dereference operator>  <qualified identifier> 
      [ <SQL argument list>  ]

<dereference operator> ::=
  <right arrow> 

<dereference operation> ::=
  <reference value expression>  <dereference operator>  <attribute name> 

<method reference> ::=
  <value expression primary>  <dereference operator>  <method name>  <SQL argument list> 

<reference resolution> ::=
  DEREF <left paren>  <reference value expression>  <right paren> 

<array element reference> ::=
  <array value expression> 
      <left bracket or trigraph>  <numeric value expression>  <right bracket or trigraph> 

<multiset element reference> ::=
  ELEMENT <left paren>  <multiset value expression>  <right paren> 

<row pattern navigation operation> ::=
    <row pattern navigation: logical> 
  | <row pattern navigation: physical> 
  | <row pattern navigation: compound> 

<row pattern navigation: logical> ::=
  [ <running or final>  ] <first or last> 
      <left paren>  <value expression>  [ <comma>  <logical offset>  ] <right paren> 

<row pattern navigation: physical> ::=
  <prev or next> 
      <left paren>  <value expression>  [ <comma>  <physical offset>  ] <right paren> 

<row pattern navigation: compound> ::=
  <prev or next>  <left paren>  [ <running or final>  ] <first or last> 
      <left paren>  <value expression>  [ <comma>  <logical offset>  ] <right paren> 
      [ <comma>  <physical offset>  ] <right paren> 

<first or last> ::=
  FIRST | LAST

<prev or next> ::=
  PREV | NEXT

<logical offset> ::=
    <simple value specification> 
  | <dynamic parameter specification> 

<physical offset> ::=
    <simple value specification> 
  | <dynamic parameter specification> 

<JSON value function> ::=
  JSON_VALUE <left paren> 
      <JSON API common syntax> 
      [ <JSON returning clause>  ]
      [ <JSON value empty behavior>  ON EMPTY ]
      [ <JSON value error behavior>  ON ERROR ]
  <right paren> 

<JSON returning clause> ::=
  RETURNING <data type> 

<JSON value empty behavior> ::=
    ERROR
  | NULL
  | DEFAULT <value expression> 

<JSON value error behavior> ::=
    ERROR
  | NULL
  | DEFAULT <value expression> 

<value expression> ::=
    <common value expression> 
  | <boolean value expression> 
  | <row value expression> 

<common value expression> ::=
         <numeric value expression> 
     |   <string value expression> 
     |   <datetime value expression> 
     |   <interval value expression> 
     |   <user-defined type value expression> 
     |   <reference value expression> 
     |   <collection value expression> 

<user-defined type value expression> ::=
  <value expression primary> 

<reference value expression> ::=
  <value expression primary> 

<collection value expression> ::=
    <array value expression> 
  | <multiset value expression> 

<numeric value expression> ::=
    <term> 
  | <numeric value expression>  <plus sign>  <term> 
  | <numeric value expression>  <minus sign>  <term> 

<term> ::=
    <factor> 
  | <term>  <asterisk>  <factor> 
  | <term>  <solidus>  <factor> 

<factor> ::=
  [ <sign>  ] <numeric primary> 

<numeric primary> ::=
    <value expression primary> 
  | <numeric value function> 

<numeric value function> ::=
    <position expression> 
  | <regex occurrences function> 
  | <regex position expression> 
  | <extract expression> 
  | <length expression> 
  | <cardinality expression> 
  | <max cardinality expression> 
  | <absolute value expression> 
  | <modulus expression> 
  | <trigonometric function> 
  | <general logarithm function> 
  | <common logarithm> 
  | <natural logarithm> 
  | <exponential function> 
  | <power function> 
  | <square root> 
  | <floor function> 
  | <ceiling function> 
  | <width bucket function> 
  | <match number function> 

<position expression> ::=
    <character position expression> 
  | <binary position expression> 

<regex occurrences function> ::=
  OCCURRENCES_REGEX <left paren> 
      <XQuery pattern>  [ FLAG <XQuery option flag>  ]
      IN <regex subject string> 
      [ FROM <start position>  ]
      [ USING <char length units>  ]
      <right paren> 

<XQuery pattern> ::=
  <character value expression> 

<XQuery option flag> ::=
  <character value expression> 

<regex subject string> ::=
  <character value expression> 

<regex position expression> ::=
  POSITION_REGEX <left paren> 
      [ <regex position start or after>  ]
      <XQuery pattern>  [ FLAG <XQuery option flag>  ]
      IN <regex subject string> 
      [ FROM <start position>  ]
      [ USING <char length units>  ]
      [ OCCURRENCE <regex occurrence>  ]
      [ GROUP <regex capture group>  ]
      <right paren> 

<regex position start or after> ::=
    START
  | AFTER

<regex occurrence> ::=
  <numeric value expression> 

<regex capture group> ::=
  <numeric value expression> 

<character position expression> ::=
  POSITION <left paren>  <character value expression 1>  IN <character value expression 2> 
      [ USING <char length units>  ] <right paren> 

<character value expression 1> ::=
  <character value expression> 

<character value expression 2> ::=
  <character value expression> 

<binary position expression> ::=
  POSITION <left paren>  <binary value expression>  IN <binary value expression>  <right paren> 

<length expression> ::=
    <char length expression> 
  | <octet length expression> 

<char length expression> ::=
  { CHAR_LENGTH | CHARACTER_LENGTH } <left paren>  <character value expression> 
      [ USING <char length units>  ] <right paren> 

<octet length expression> ::=
  OCTET_LENGTH <left paren>  <string value expression>  <right paren> 

<extract expression> ::=
  EXTRACT <left paren>  <extract field>  FROM <extract source>  <right paren> 

<extract field> ::=
    <primary datetime field> 
  | <time zone field> 

<time zone field> ::=
    TIMEZONE_HOUR
  | TIMEZONE_MINUTE

<extract source> ::=
    <datetime value expression> 
  | <interval value expression> 

<cardinality expression> ::=
  CARDINALITY <left paren>  <collection value expression>  <right paren> 

<max cardinality expression> ::=
  ARRAY_MAX_CARDINALITY <left paren>  <array value expression>  <right paren> 

<absolute value expression> ::=
  ABS <left paren>  <numeric value expression>  <right paren> 

<modulus expression> ::=
  MOD <left paren>  <numeric value expression dividend>  <comma> 
      <numeric value expression divisor>  <right paren> 

<numeric value expression dividend> ::=
  <numeric value expression> 

<numeric value expression divisor> ::=
  <numeric value expression> 

<trigonometric function> ::=
  <trigonometric function name>  <left paren>  <numeric value expression>  <right paren> 

<trigonometric function name> ::=
  SIN | COS | TAN | SINH | COSH | TANH | ASIN | ACOS | ATAN

<general logarithm function> ::=
  LOG <left paren>  <general logarithm base>  <comma> 
      <general logarithm argument>  <right paren> 

<general logarithm base> ::=
  <numeric value expression> 

<general logarithm argument> ::=
  <numeric value expression> 

<common logarithm> ::=
  LOG10 <left paren>  <numeric value expression>  <right paren> 

<natural logarithm> ::=
  LN <left paren>  <numeric value expression>  <right paren> 

<exponential function> ::=
  EXP <left paren>  <numeric value expression>  <right paren> 

<power function> ::=
  POWER <left paren>  <numeric value expression base>  <comma> 
      <numeric value expression exponent>  <right paren> 

<numeric value expression base> ::=
  <numeric value expression> 

<numeric value expression exponent> ::=
  <numeric value expression> 

<square root> ::=
  SQRT <left paren>  <numeric value expression>  <right paren> 

<floor function> ::=
  FLOOR <left paren>  <numeric value expression>  <right paren> 

<ceiling function> ::=
  { CEIL | CEILING } <left paren>  <numeric value expression>  <right paren> 

<width bucket function> ::=
  WIDTH_BUCKET <left paren>  <width bucket operand>  <comma>  <width bucket bound 1>  <comma> 
      <width bucket bound 2>  <comma>  <width bucket count>  <right paren> 

<width bucket operand> ::=
  <numeric value expression> 

<width bucket bound 1> ::=
  <numeric value expression> 

<width bucket bound 2> ::=
  <numeric value expression> 

<width bucket count> ::=
  <numeric value expression> 

<match number function> ::=
  MATCH_NUMBER <left paren>  <right paren> 

<string value expression> ::=
    <character value expression> 
  | <binary value expression> 

<character value expression> ::=
    <concatenation> 
  | <character factor> 

<concatenation> ::=
  <character value expression>  <concatenation operator>  <character factor> 

<character factor> ::=
  <character primary>  [ <collate clause>  ]

<character primary> ::=
    <value expression primary> 
  | <string value function> 

<binary value expression> ::=
    <binary concatenation> 
  | <binary factor> 

<binary factor> ::=
  <binary primary> 

<binary primary> ::=
    <value expression primary> 
  | <string value function> 

<binary concatenation> ::=
  <binary value expression>  <concatenation operator>  <binary factor> 

<string value function> ::=
    <character value function> 
  | <binary value function> 
  | <JSON value constructor> 
  | <JSON query> 

<character value function> ::=
    <character substring function> 
  | <regular expression substring function> 
  | <regex substring function> 
  | <fold> 
  | <transcoding> 
  | <character transliteration> 
  | <regex transliteration> 
  | <trim function> 
  | <character overlay function> 
  | <normalize function> 
  | <specific type method> 
  | <classifier function> 

<character substring function> ::=
  SUBSTRING <left paren>  <character value expression>  FROM <start position> 
      [ FOR <string length>  ] [ USING <char length units>  ] <right paren> 

<regular expression substring function> ::=
  SUBSTRING <left paren>  <character value expression>  SIMILAR <character value expression> 
      ESCAPE <escape character>  <right paren> 

<regex substring function> ::=
  SUBSTRING_REGEX <left paren> 
      <XQuery pattern>  [ FLAG <XQuery option flag>  ]
      IN <regex subject string> 
      [ FROM <start position>  ]
      [ USING <char length units>  ]
      [ OCCURRENCE <regex occurrence>  ]
      [ GROUP <regex capture group>  ]
      <right paren> 

<fold> ::=
  { UPPER | LOWER } <left paren>  <character value expression>  <right paren> 

<transcoding> ::=
  CONVERT <left paren>  <character value expression> 
      USING <transcoding name>  <right paren> 

<character transliteration> ::=
  TRANSLATE <left paren>  <character value expression> 
      USING <transliteration name>  <right paren> 

<regex transliteration> ::=
  TRANSLATE_REGEX <left paren> 
      <XQuery pattern>  [ FLAG <XQuery option flag>  ]
      IN <regex subject string> 
      [ WITH <XQuery replacement string>  ]
      [ FROM <start position>  ]
      [ USING <char length units>  ]
      [ OCCURRENCE <regex transliteration occurrence>  ]
      <right paren> 

<XQuery replacement string> ::=
  <character value expression> 

<regex transliteration occurrence> ::=
    <regex occurrence> 
  | ALL

<trim function> ::=
  TRIM <left paren>  <trim operands>  <right paren> 

<trim operands> ::=
  [ [ <trim specification>  ] [ <trim character>  ] FROM ] <trim source> 

<trim source> ::=
  <character value expression> 

<trim specification> ::=
    LEADING
  | TRAILING
  | BOTH

<trim character> ::=
  <character value expression> 

<character overlay function> ::=
  OVERLAY <left paren>  <character value expression>  PLACING <character value expression> 
      FROM <start position>  [ FOR <string length>  ]
      [ USING <char length units>  ] <right paren> 

<normalize function> ::=
  NORMALIZE <left paren>  <character value expression> 
      [ <comma>  <normal form>  [ <comma>  <normalize function result length>  ] ] <right paren> 

<normal form> ::=
    NFC
  | NFD
  | NFKC
  | NFKD

<normalize function result length> ::=
    <character length> 
  | <character large object length> 

<specific type method> ::=
  <user-defined type value expression>  <period>  SPECIFICTYPE
      [ <left paren>  <right paren>  ]

<binary value function> ::=
       <binary substring function> 
     | <binary trim function> 
     | <binary overlay function> 

<binary substring function> ::=
  SUBSTRING <left paren>  <binary value expression>  FROM <start position> 
      [ FOR <string length>  ] <right paren> 

<binary trim function> ::=
  TRIM <left paren>  <binary trim operands>  <right paren> 

<binary trim operands> ::=
  [ [ <trim specification>  ] [ <trim octet>  ] FROM ] <binary trim source> 

<binary trim source> ::=
  <binary value expression> 

<trim octet> ::=
  <binary value expression> 

<binary overlay function> ::=
  OVERLAY <left paren>  <binary value expression>  PLACING <binary value expression> 
      FROM <start position>  [ FOR <string length>  ] <right paren> 

<start position> ::=
  <numeric value expression> 

<string length> ::=
  <numeric value expression> 

<classifier function> ::=
  CLASSIFIER <left paren>  [ <row pattern variable name>  ] <right paren> 

<JSON value constructor> ::=
    <JSON object constructor> 
  | <JSON array constructor> 

<JSON object constructor> ::=
  JSON_OBJECT <left paren> 
      [ <JSON name and value>  [ { <comma>  <JSON name and value>  }... ]
      [ <JSON constructor null clause>  ]
      [ <JSON key uniqueness constraint>  ] ]
      [ <JSON output clause>  ]
      <right paren> 

<JSON name and value> ::=
    [ KEY ] <JSON name>  VALUE <JSON value expression> 
  | <JSON name>  <colon>  <JSON value expression> 

<JSON name> ::=
  <character value expression> 

<JSON constructor null clause> ::=
    NULL ON NULL
  | ABSENT ON NULL

<JSON array constructor> ::=
    <JSON array constructor by enumeration> 
  | <JSON array constructor by query> 

<JSON array constructor by enumeration> ::=
  JSON_ARRAY <left paren> 
      [ <JSON value expression>  [ { <comma>  <JSON value expression>  }... ]
      [ <JSON constructor null clause>  ] ]
      [ <JSON output clause>  ]
      <right paren> 

<JSON array constructor by query> ::=
  JSON_ARRAY <left paren> 
      <query expression> 
      [ <JSON input clause>  ]
      [ <JSON constructor null clause>  ]
      [ <JSON output clause>  ]
      <right paren> 

<JSON query> ::=
  JSON_QUERY <left paren> 
  <JSON API common syntax> 
      [ <JSON output clause>  ]
      [ <JSON query wrapper behavior>  WRAPPER ]
      [ <JSON query quotes behavior>  QUOTES [ ON SCALAR STRING ] ]
      [ <JSON query empty behavior>  ON EMPTY ]
      [ <JSON query error behavior>  ON ERROR ]
  <right paren> 

<JSON query wrapper behavior> ::=
    WITHOUT [ ARRAY ]
  | WITH [ CONDITIONAL | UNCONDITIONAL ] [ ARRAY ]

<JSON query quotes behavior> ::=
    KEEP
  | OMIT

<JSON query empty behavior> ::=
    ERROR
  | NULL
  | EMPTY ARRAY
  | EMPTY OBJECT

<JSON query error behavior> ::=
    ERROR
  | NULL
  | EMPTY ARRAY
  | EMPTY OBJECT

<datetime value expression> ::=
    <datetime term> 
  | <interval value expression>  <plus sign>  <datetime term> 
  | <datetime value expression>  <plus sign>  <interval term> 
  | <datetime value expression>  <minus sign>  <interval term> 

<datetime term> ::=
  <datetime factor> 

<datetime factor> ::=
  <datetime primary>  [ <time zone>  ]

<datetime primary> ::=
    <value expression primary> 
  | <datetime value function> 

<time zone> ::=
  AT <time zone specifier> 

<time zone specifier> ::=
    LOCAL
  | TIME ZONE <interval primary> 

<datetime value function> ::=
    <current date value function> 
  | <current time value function> 
  | <current timestamp value function> 
  | <current local time value function> 
  | <current local timestamp value function> 

<current date value function> ::=
  CURRENT_DATE

<current time value function> ::=
  CURRENT_TIME [ <left paren>  <time precision>  <right paren>  ]

<current local time value function> ::=
  LOCALTIME [ <left paren>  <time precision>  <right paren>  ]

<current timestamp value function> ::=
  CURRENT_TIMESTAMP [ <left paren>  <timestamp precision>  <right paren>  ]

<current local timestamp value function> ::=
  LOCALTIMESTAMP [ <left paren>  <timestamp precision>  <right paren>  ]

<interval value expression> ::=
    <interval term> 
  | <interval value expression 1>  <plus sign>  <interval term 1> 
  | <interval value expression 1>  <minus sign>  <interval term 1> 
  | <left paren>  <datetime value expression>  <minus sign>  <datetime term>  <right paren> 
      <interval qualifier> 

<interval term> ::=
    <interval factor> 
  | <interval term 2>  <asterisk>  <factor> 
  | <interval term 2>  <solidus>  <factor> 
  | <term>  <asterisk>  <interval factor> 

<interval factor> ::=
  [ <sign>  ] <interval primary> 

<interval primary> ::=
    <value expression primary>  [ <interval qualifier>  ]
  | <interval value function> 

<interval value expression 1> ::=
  <interval value expression> 

<interval term 1> ::=
  <interval term> 

<interval term 2> ::=
  <interval term> 

<interval value function> ::=
  <interval absolute value function> 

<interval absolute value function> ::=
  ABS <left paren>  <interval value expression>  <right paren> 

<boolean value expression> ::=
    <boolean term> 
  | <boolean value expression>  OR <boolean term> 

<boolean term> ::=
    <boolean factor> 
  | <boolean term>  AND <boolean factor> 

<boolean factor> ::=
  [ NOT ] <boolean test> 

<boolean test> ::=
  <boolean primary>  [ IS [ NOT ] <truth value>  ]

<truth value> ::=
    TRUE
  | FALSE
  | UNKNOWN

<boolean primary> ::=
    <predicate> 
  | <boolean predicand> 

<boolean predicand> ::=
    <parenthesized boolean value expression> 
  | <nonparenthesized value expression primary> 

<parenthesized boolean value expression> ::=
  <left paren>  <boolean value expression>  <right paren> 

<array value expression> ::=
    <array concatenation> 
  | <array primary> 

<array concatenation> ::=
  <array value expression 1>  <concatenation operator>  <array primary> 

<array value expression 1> ::=
  <array value expression> 

<array primary> ::=
    <array value function> 
  | <value expression primary> 

<array value function> ::=
  <trim array function> 

<trim array function> ::=
  TRIM_ARRAY <left paren>  <array value expression>  <comma>  <numeric value expression>  <right paren> 

<array value constructor> ::=
    <array value constructor by enumeration> 
  | <array value constructor by query> 

<array value constructor by enumeration> ::=
  ARRAY <left bracket or trigraph>  <array element list>  <right bracket or trigraph> 

<array element list> ::=
  <array element>  [ { <comma>  <array element>  }... ]

<array element> ::=
  <value expression> 

<array value constructor by query> ::=
  ARRAY <table subquery> 

<multiset value expression> ::=
    <multiset term> 
  | <multiset value expression>  MULTISET UNION [ ALL | DISTINCT ] <multiset term> 
  | <multiset value expression>  MULTISET EXCEPT [ ALL | DISTINCT ] <multiset term> 

<multiset term> ::=
    <multiset primary> 
  | <multiset term>  MULTISET INTERSECT [ ALL | DISTINCT ] <multiset primary> 

<multiset primary> ::=
    <multiset value function> 
  | <value expression primary> 

<multiset value function> ::=
  <multiset set function> 

<multiset set function> ::=
  SET <left paren>  <multiset value expression>  <right paren> 

<multiset value constructor> ::=
    <multiset value constructor by enumeration> 
  | <multiset value constructor by query> 
  | <table value constructor by query> 

<multiset value constructor by enumeration> ::=
  MULTISET <left bracket or trigraph>  <multiset element list>  <right bracket or trigraph> 

<multiset element list> ::=
  <multiset element>  [ { <comma>  <multiset element>  }... ]

<multiset element> ::=
  <value expression> 

<multiset value constructor by query> ::=
  MULTISET <table subquery> 

<table value constructor by query> ::=
  TABLE <table subquery> 

<row value constructor> ::=
    <common value expression> 
  | <boolean value expression> 
  | <explicit row value constructor> 

<explicit row value constructor> ::=
    <left paren>  <row value constructor element>  <comma> 
        <row value constructor element list>  <right paren> 
  | ROW <left paren>  <row value constructor element list>  <right paren> 
  | <row subquery> 

<row value constructor element list> ::=
  <row value constructor element>  [ { <comma>  <row value constructor element>  }... ]

<row value constructor element> ::=
  <value expression> 

<contextually typed row value constructor> ::=
    <common value expression> 
  | <boolean value expression> 
  | <contextually typed value specification> 
  | <left paren>  <contextually typed value specification>  <right paren> 
  | <left paren>  <contextually typed row value constructor element>  <comma> 
      <contextually typed row value constructor element list>  <right paren> 
  | ROW <left paren>  <contextually typed row value constructor element list>  <right paren> 

<contextually typed row value constructor element list> ::=
  <contextually typed row value constructor element> 
      [ { <comma>  <contextually typed row value constructor element>  }... ]

<contextually typed row value constructor element> ::=
    <value expression> 
  | <contextually typed value specification> 

<row value constructor predicand> ::=
    <common value expression> 
  | <boolean predicand> 
  | <explicit row value constructor> 

<row value expression> ::=
    <row value special case> 
  | <explicit row value constructor> 

<table row value expression> ::=
    <row value special case> 
  | <row value constructor> 

<contextually typed row value expression> ::=
    <row value special case> 
  | <contextually typed row value constructor> 

<row value predicand> ::=
    <row value special case> 
  | <row value constructor predicand> 

<row value special case> ::=
  <nonparenthesized value expression primary> 

<table value constructor> ::=
  VALUES <row value expression list> 

<row value expression list> ::=
  <table row value expression>  [ { <comma>  <table row value expression>  }... ]

<contextually typed table value constructor> ::=
  VALUES <contextually typed row value expression list> 

<contextually typed row value expression list> ::=
  <contextually typed row value expression> 
      [ { <comma>  <contextually typed row value expression>  }... ]

<table expression> ::=
  <from clause> 
      [ <where clause>  ]
      [ <group by clause>  ]
      [ <having clause>  ]
      [ <window clause>  ]

<from clause> ::=
  FROM <table reference list> 

<table reference list> ::=
  <table reference>  [ { <comma>  <table reference>  }... ]

<table reference> ::=
    <table factor> 
  | <joined table> 

<table factor> ::=
  <table primary>  [ <sample clause>  ]

<sample clause> ::=
  TABLESAMPLE <sample method>  <left paren>  <sample percentage>  <right paren> 
      [ <repeatable clause>  ]

<sample method> ::=
    BERNOULLI
  | SYSTEM

<repeatable clause> ::=
  REPEATABLE <left paren>  <repeat argument>  <right paren> 

<sample percentage> ::=
  <numeric value expression> 

<repeat argument> ::=
  <numeric value expression> 

<table primary> ::=
    <table or query name> 
        [ <query system time period specification>  ]
        [ <correlation or recognition>  ]
  | <derived table>  <correlation or recognition> 
  | <lateral derived table>  <correlation or recognition> 
  | <collection derived table>  <correlation or recognition> 
  | <table function derived table>  <correlation or recognition> 
  | <PTF derived table>  [ <correlation or recognition>  ]
  | <only spec>  [ <correlation or recognition>  ]
  | <data change delta table>  [ <correlation or recognition>  ]
  | <JSON table>  <correlation or recognition> 
  | <JSON table primitive>  <correlation name> 
  | <parenthesized joined table> 

<correlation or recognition> ::=
    [ AS ] <correlation name> 
        [ <parenthesized derived column list>  ]
  | <row pattern recognition clause and name> 
<query system time period specification> ::=
    FOR SYSTEM_TIME AS OF <point in time 1> 
  | FOR SYSTEM_TIME BETWEEN [ ASYMMETRIC | SYMMETRIC ]
      <point in time 1>  AND <point in time 2> 
  | FOR SYSTEM_TIME FROM <point in time 1>  TO <point in time 2> 

<point in time 1> ::=
  <point in time> 

<point in time 2> ::=
  <point in time> 

<point in time> ::=
  <datetime value expression> 

<only spec> ::=
  ONLY <left paren>  <table or query name>  <right paren> 

<lateral derived table> ::=
  LATERAL <table subquery> 

<collection derived table> ::=
  UNNEST <left paren>  <collection value expression> 
      [ { <comma>  <collection value expression>  }... ] <right paren> 
      [ WITH ORDINALITY ]

<table function derived table> ::=
  TABLE <left paren>  <collection value expression>  <right paren> 

<derived table> ::=
  <table subquery> 

<PTF derived table> ::=
  TABLE <left paren>  <routine invocation>  <right paren> 

<table or query name> ::=
    <table name> 
  | <transition table name> 
  | <query name> 

<derived column list> ::=
  <column name list> 

<column name list> ::=
  <column name>  [ { <comma>  <column name>  }... ]

<data change delta table> ::=
  <result option>  TABLE <left paren>  <data change statement>  <right paren> 

<data change statement> ::=
    <delete statement: searched> 
  | <insert statement> 
  | <merge statement> 
  | <update statement: searched> 

<result option> ::=
    FINAL
  | NEW
  | OLD

<parenthesized joined table> ::=
    <left paren>  <parenthesized joined table>  <right paren> 
  | <left paren>  <joined table>  <right paren> 

<row pattern recognition clause and name> ::=
  [ [ AS ] <row pattern input name> 
      [ <row pattern input derived column list>  ] ]
      <row pattern recognition clause>  [ [ AS ] <row pattern output name> 
      [ <row pattern output derived column list>  ] ]

<row pattern input name> ::=
  <correlation name> 

<row pattern output name> ::=
  <correlation name> 

<row pattern input derived column list> ::=
  <parenthesized derived column list> 

<row pattern output derived column list> ::=
  <parenthesized derived column list> 

<parenthesized derived column list> ::=
  <left paren>  <derived column list>  <right paren> 

<row pattern recognition clause> ::=
  MATCH_RECOGNIZE <left paren> 
      [ <row pattern partition by>  ]
      [ <row pattern order by>  ]
      [ <row pattern measures>  ]
      [ <row pattern rows per match>  ]
      <row pattern common syntax> 
      <right paren> 

<row pattern partition by> ::=
  PARTITION BY <row pattern partition list> 

<row pattern partition list> ::=
  <row pattern partition column>  [ { <comma>  <row pattern partition column>  }... ]

<row pattern partition column> ::=
  <column reference>  [ <collate clause>  ]

<row pattern order by> ::=
  ORDER BY <sort specification list> 

<row pattern rows per match> ::=
    ONE ROW PER MATCH
  | ALL ROWS PER MATCH [ <row pattern empty match handling>  ]

<row pattern empty match handling> ::=
    SHOW EMPTY MATCHES
  | OMIT EMPTY MATCHES
  | WITH UNMATCHED ROWS

<row pattern measures> ::=
  MEASURES <row pattern measure list> 

<row pattern measure list> ::=
  <row pattern measure definition>  [ { <comma>  <row pattern measure definition>  }... ]

<row pattern measure definition> ::=
  <row pattern measure expression>  AS <measure name> 

<row pattern measure expression> ::=
  <value expression> 

<row pattern common syntax> ::=
  [ AFTER MATCH <row pattern skip to>  ]
      [ <row pattern initial or seek>  ]
      PATTERN <left paren>  <row pattern>  <right paren> 
      [ <row pattern subset clause>  ]
      DEFINE <row pattern definition list> 

<row pattern skip to> ::=
    SKIP TO NEXT ROW
  | SKIP PAST LAST ROW
  | SKIP TO FIRST <row pattern skip to variable name> 
  | SKIP TO LAST <row pattern skip to variable name> 
  | SKIP TO <row pattern skip to variable name> 

<row pattern skip to variable name> ::=
  <row pattern variable name> 

<row pattern initial or seek> ::=
    INITIAL
  | SEEK

<row pattern> ::=
    <row pattern term> 
  | <row pattern alternation> 

<row pattern alternation> ::=
  <row pattern>  <vertical bar>  <row pattern term> 

<row pattern term> ::=
    <row pattern factor> 
  | <row pattern term>  <row pattern factor> 

<row pattern factor> ::=
  <row pattern primary>  [ <row pattern quantifier>  ]

<row pattern quantifier> ::=
    <asterisk>  [ <question mark>  ]
  | <plus sign>  [ <question mark>  ]
  | <question mark>  [ <question mark>  ]
  | <left brace>  [ <unsigned integer>  ] <comma>  [ <unsigned integer>  ] <right brace> 
      [ <question mark>  ]
  | <left brace>  <unsigned integer>  <right brace> 

<row pattern primary> ::=
    <row pattern primary variable name> 
  | <dollar sign> 
  | <circumflex> 
  | <left paren>  [ <row pattern>  ] <right paren> 
  | <left brace minus>  <row pattern>  <right minus brace> 
  | <row pattern permute> 

<row pattern primary variable name> ::=
  <row pattern variable name> 

<row pattern permute> ::=
  PERMUTE <left paren>  <row pattern>  [ { <comma>  <row pattern>  }... ] <right paren> 

<row pattern subset clause> ::=
  SUBSET <row pattern subset list> 

<row pattern subset list> ::=
  <row pattern subset item>  [ { <comma>  <row pattern subset item>  }... ]

<row pattern subset item> ::=
  <row pattern subset item variable name>  <equals operator> 
      <left paren>  <row pattern subset rhs>  <right paren> 

<row pattern subset item variable name> ::=
  <row pattern variable name> 

<row pattern subset rhs> ::=
  <row pattern subset rhs variable name> 
      [ { <comma>  <row pattern subset rhs variable name>  }... ]

<row pattern subset rhs variable name> ::=
  <row pattern variable name> 

<row pattern definition list> ::=
  <row pattern definition>  [ { <comma>  <row pattern definition>  }... ]

<row pattern definition> ::=
  <row pattern definition variable name>  AS <row pattern definition search condition> 

<row pattern definition variable name> ::=
  <row pattern variable name> 

<row pattern definition search condition> ::=
  <search condition> 

<joined table> ::=
    <cross join> 
  | <qualified join> 
  | <natural join> 

<cross join> ::=
  <table reference>  CROSS JOIN <table factor> 

<qualified join> ::=
  { <table reference>  | <partitioned join table>  }
      [ <join type>  ] JOIN
      { <table reference>  | <partitioned join table>  }
      <join specification> 

<partitioned join table> ::=
  <table factor>  PARTITION BY
      <partitioned join column reference list> 

<partitioned join column reference list> ::=
  <left paren>  <partitioned join column reference> 
      [ { <comma>  <partitioned join column reference>  }... ]
      <right paren> 

<partitioned join column reference> ::=
  <column reference> 

<natural join> ::=
  { <table reference>  | <partitioned join table>  }
      NATURAL [ <join type>  ] JOIN
      { <table factor>  | <partitioned join table>  }

<join specification> ::=
    <join condition> 
  | <named columns join> 

<join condition> ::=
  ON <search condition> 

<named columns join> ::=
  USING <left paren>  <join column list>  <right paren>  [ AS <join correlation name>  ]

<join correlation name> ::=
  <correlation name> 

<join type> ::=
    INNER
  | <outer join type>  [ OUTER ]

<outer join type> ::=
    LEFT
  | RIGHT
  | FULL

<join column list> ::=
  <column name list> 

<JSON table> ::=
  JSON_TABLE <left paren> 
      <JSON API common syntax> 
      <JSON table columns clause> 
      [ <JSON table plan clause>  ]
      [ <JSON table error behavior>  ON ERROR ]
  <right paren> 

<JSON table columns clause> ::=
  COLUMNS <left paren> 
      <JSON table column definition>  [ { <comma>  <JSON table column definition>  }... ]
  <right paren> 

<JSON table column definition> ::=
    <JSON table ordinality column definition> 
  | <JSON table regular column definition> 
  | <JSON table formatted column definition> 
  | <JSON table nested columns> 

<JSON table ordinality column definition> ::=
  <column name>  FOR ORDINALITY

<JSON table regular column definition> ::=
  <column name>  <data type> 
      [ PATH <JSON table column path specification>  ]
      [ <JSON table column empty behavior>  ON EMPTY ]
      [ <JSON table column error behavior>  ON ERROR ]

<JSON table column empty behavior> ::=
    ERROR
  | NULL
  | DEFAULT <value expression> 

<JSON table column error behavior> ::=
    ERROR
  | NULL
  | DEFAULT <value expression> 

<JSON table column path specification> ::=
  <JSON path specification> 

<JSON table formatted column definition> ::=
  <column name>  <data type> 
      FORMAT <JSON representation> 
      [ PATH <JSON table column path specification>  ]
      [ <JSON table formatted column wrapper behavior>  WRAPPER ]
      [ <JSON table formatted column quotes behavior>  QUOTES [ ON SCALAR STRING ] ]
      [ <JSON table formatted column empty behavior>  ON EMPTY ]
      [ <JSON table formatted column error behavior>  ON ERROR ]

<JSON table formatted column wrapper behavior> ::=
    WITHOUT [ ARRAY ]
  | WITH [ CONDITIONAL | UNCONDITIONAL ] [ ARRAY ]

<JSON table formatted column quotes behavior> ::=
    KEEP
  | OMIT

<JSON table formatted column empty behavior> ::=
    ERROR
  | NULL
  | EMPTY ARRAY
  | EMPTY OBJECT

<JSON table formatted column error behavior> ::=
    ERROR
  | NULL
  | EMPTY ARRAY
  | EMPTY OBJECT

<JSON table nested columns> ::=
  NESTED [ PATH ] <JSON table nested path specification> 
      [ AS <JSON table nested path name>  ]
  <JSON table columns clause> 

<JSON table nested path specification> ::=
  <JSON path specification> 

<JSON table nested path name> ::=
  <JSON table path name> 

<JSON table path name> ::=
  <identifier> 

<JSON table plan clause> ::=
    <JSON table specific plan> 
  | <JSON table default plan> 

<JSON table specific plan> ::=
  PLAN <left paren>  <JSON table plan>  <right paren> 

<JSON table plan> ::=
    <JSON table path name> 
  | <JSON table plan parent/child> 
  | <JSON table plan sibling> 

<JSON table plan parent/child> ::=
    <JSON table plan outer> 
  | <JSON table plan inner> 

<JSON table plan outer> ::=
  <JSON table path name>  OUTER <JSON table plan primary> 

<JSON table plan inner> ::=
  <JSON table path name>  INNER <JSON table plan primary> 

<JSON table plan sibling> ::=
    <JSON table plan union> 
  | <JSON table plan cross> 

<JSON table plan union> ::=
  <JSON table plan primary>  UNION <JSON table plan primary> 
      [ { UNION <JSON table plan primary>  }... ]

<JSON table plan cross> ::=
  <JSON table plan primary>  CROSS <JSON table plan primary> 
      [ { CROSS <JSON table plan primary>  }... ]

<JSON table plan primary> ::=
    <JSON table path name> 
  | <left paren>  <JSON table plan>  <right paren> 

<JSON table default plan> ::=
  PLAN DEFAULT <left paren> 
      <JSON table default plan choices>  <right paren> 

<JSON table default plan choices> ::=
    <JSON table default plan inner/outer> 
        [ <comma>  <JSON table default plan union/cross>  ]
  | <JSON table default plan union/cross> 
      [ <comma>  <JSON table default plan inner/outer>  ]

<JSON table default plan inner/outer> ::=
  INNER | OUTER

<JSON table default plan union/cross> ::=
  UNION | CROSS

<JSON table error behavior> ::=
    ERROR
  | EMPTY

<JSON table primitive> ::=
  JSON_TABLE_PRIMITIVE <left paren> 
      <JSON API common syntax> 
      <JSON table primitive columns clause> 
      <JSON table error behavior>  ON ERROR
  <right paren> 

<JSON table primitive columns clause> ::=
  COLUMNS <left paren> 
      <JSON table primitive column definition> 
      [ { <comma>  <JSON table primitive column definition>  }... ]
  <right paren> 

<JSON table primitive column definition> ::=
    <JSON table ordinality column definition> 
  | <JSON table regular column definition> 
  | <JSON table formatted column definition> 
  | <JSON table primitive chaining column> 

<JSON table primitive chaining column> ::=
  <column name>  FOR CHAINING

<where clause> ::=
  WHERE <search condition> 

<group by clause> ::=
  GROUP BY [ <set quantifier>  ] <grouping element list> 

<grouping element list> ::=
  <grouping element>  [ { <comma>  <grouping element>  }... ]

<grouping element> ::=
    <ordinary grouping set> 
  | <rollup list> 
  | <cube list> 
  | <grouping sets specification> 
  | <empty grouping set> 

<ordinary grouping set> ::=
    <grouping column reference> 
  | <left paren>  <grouping column reference list>  <right paren> 

<grouping column reference> ::=
  <column reference>  [ <collate clause>  ]

<grouping column reference list> ::=
  <grouping column reference>  [ { <comma>  <grouping column reference>  }... ]

<rollup list> ::=
  ROLLUP <left paren>  <ordinary grouping set list>  <right paren> 

<ordinary grouping set list> ::=
  <ordinary grouping set>  [ { <comma>  <ordinary grouping set>  }... ]

<cube list> ::=
  CUBE <left paren>  <ordinary grouping set list>  <right paren> 

<grouping sets specification> ::=
  GROUPING SETS <left paren>  <grouping set list>  <right paren> 

<grouping set list> ::=
  <grouping set>  [ { <comma>  <grouping set>  }... ]

<grouping set> ::=
    <ordinary grouping set> 
  | <rollup list> 
  | <cube list> 
  | <grouping sets specification> 
  | <empty grouping set> 

<empty grouping set> ::=
  <left paren>  <right paren> 

<having clause> ::=
  HAVING <search condition> 

<window clause> ::=
  WINDOW <window definition list> 

<window definition list> ::=
  <window definition>  [ { <comma>  <window definition>  }... ]

<window definition> ::=
  <new window name>  AS <window specification> 

<new window name> ::=
  <window name> 

<window specification> ::=
  <left paren>  <window specification details>  <right paren> 

<window specification details> ::=
  [ <existing window name>  ]
      [ <window partition clause>  ]
      [ <window order clause>  ]
      [ <window frame clause>  ]

<existing window name> ::=
  <window name> 

<window partition clause> ::=
  PARTITION BY <window partition column reference list> 

<window partition column reference list> ::=
  <window partition column reference> 
      [ { <comma>  <window partition column reference>  }... ]

<window partition column reference> ::=
  <column reference>  [ <collate clause>  ]

<window order clause> ::=
  ORDER BY <sort specification list> 

<window frame clause> ::=
  [ <row pattern measures>  ]
      <window frame units>  <window frame extent> 
      [ <window frame exclusion>  ]
      [ <row pattern common syntax>  ]

<window frame units> ::=
    ROWS
  | RANGE
  | GROUPS

<window frame extent> ::=
    <window frame start> 
  | <window frame between> 

<window frame start> ::=
    UNBOUNDED PRECEDING
  | <window frame preceding> 
  | CURRENT ROW

<window frame preceding> ::=
  <unsigned value specification>  PRECEDING

<window frame between> ::=
  BETWEEN <window frame bound 1>  AND <window frame bound 2> 

<window frame bound 1> ::=
  <window frame bound> 

<window frame bound 2> ::=
  <window frame bound> 

<window frame bound> ::=
    <window frame start> 
  | UNBOUNDED FOLLOWING
  | <window frame following> 

<window frame following> ::=
  <unsigned value specification>  FOLLOWING

<window frame exclusion> ::=
    EXCLUDE CURRENT ROW
  | EXCLUDE GROUP
  | EXCLUDE TIES
  | EXCLUDE NO OTHERS

<query specification> ::=
  SELECT [ <set quantifier>  ] <select list>  <table expression> 

<select list> ::=
    <asterisk> 
  | <select sublist>  [ { <comma>  <select sublist>  }... ]

<select sublist> ::=
    <derived column> 
  | <qualified asterisk> 

<qualified asterisk> ::=
    <asterisked identifier chain>  <period>  <asterisk> 
  | <all fields reference> 

<asterisked identifier chain> ::=
  <asterisked identifier>  [ { <period>  <asterisked identifier>  }... ]

<asterisked identifier> ::=
  <identifier> 

<derived column> ::=
  <value expression>  [ <as clause>  ]

<as clause> ::=
  [ AS ] <column name> 

<all fields reference> ::=
  <value expression primary>  <period>  <asterisk> 
      [ AS <left paren>  <all fields column name list>  <right paren>  ]

<all fields column name list> ::=
  <column name list> 

<query expression> ::=
  [ <with clause>  ] <query expression body> 
      [ <order by clause>  ] [ <result offset clause>  ] [ <fetch first clause>  ]

<with clause> ::=
  WITH [ RECURSIVE ] <with list> 

<with list> ::=
  <with list element>  [ { <comma>  <with list element>  }... ]

<with list element> ::=
  <query name>  [ <left paren>  <with column list>  <right paren>  ]
      AS <table subquery>  [ <search or cycle clause>  ]

<with column list> ::=
  <column name list> 

<query expression body> ::=
    <query term> 
  | <query expression body>  UNION [ ALL | DISTINCT ]
      [ <corresponding spec>  ] <query term> 
  | <query expression body>  EXCEPT [ ALL | DISTINCT ]
      [ <corresponding spec>  ] <query term> 

<query term> ::=
    <query primary> 
  | <query term>  INTERSECT [ ALL | DISTINCT ]
      [ <corresponding spec>  ] <query primary> 

<query primary> ::=
    <simple table> 
  | <left paren>  <query expression body> 
      [ <order by clause>  ] [ <result offset clause>  ] [ <fetch first clause>  ]
      <right paren> 

<simple table> ::=
    <query specification> 
  | <table value constructor> 
  | <explicit table> 

<explicit table> ::=
  TABLE <table or query name> 

<corresponding spec> ::=
  CORRESPONDING [ BY <left paren>  <corresponding column list>  <right paren>  ]

<corresponding column list> ::=
  <column name list> 

<order by clause> ::=
  ORDER BY <sort specification list> 

<result offset clause> ::=
  OFFSET <offset row count>  { ROW | ROWS }

<fetch first clause> ::=
  FETCH { FIRST | NEXT } [ <fetch first quantity>  ] { ROW | ROWS } { ONLY | WITH TIES }

<fetch first quantity> ::=
    <fetch first row count> 
  | <fetch first percentage> 

<offset row count> ::=
  <simple value specification> 

<fetch first row count> ::=
  <simple value specification> 

<fetch first percentage> ::=
  <simple value specification>  PERCENT

<search or cycle clause> ::=
    <search clause> 
  | <cycle clause> 
  | <search clause>  <cycle clause> 

<search clause> ::=
  SEARCH <recursive search order>  SET <sequence column> 

<recursive search order> ::=
    DEPTH FIRST BY <column name list> 
  | BREADTH FIRST BY <column name list> 

<sequence column> ::=
  <column name> 

<cycle clause> ::=
  CYCLE <cycle column list>  SET <cycle mark column>  TO <cycle mark value> 
      DEFAULT <non-cycle mark value>  USING <path column> 

<cycle column list> ::=
  <cycle column>  [ { <comma>  <cycle column>  }... ]

<cycle column> ::=
  <column name> 

<cycle mark column> ::=
  <column name> 

<path column> ::=
  <column name> 

<cycle mark value> ::=
  <value expression> 

<non-cycle mark value> ::=
  <value expression> 

<scalar subquery> ::=
  <subquery> 

<row subquery> ::=
  <subquery> 

<table subquery> ::=
  <subquery> 

<subquery> ::=
  <left paren>  <query expression>  <right paren> 

<predicate> ::=
    <comparison predicate> 
  | <between predicate> 
  | <in predicate> 
  | <like predicate> 
  | <similar predicate> 
  | <regex like predicate> 
  | <null predicate> 
  | <quantified comparison predicate> 
  | <exists predicate> 
  | <unique predicate> 
  | <normalized predicate> 
  | <match predicate> 
  | <overlaps predicate> 
  | <distinct predicate> 
  | <member predicate> 
  | <submultiset predicate> 
  | <set predicate> 
  | <type predicate> 
  | <period predicate> 
  | <JSON predicate> 
  | <JSON exists predicate> 

<comparison predicate> ::=
  <row value predicand>  <comparison predicate part 2> 

<comparison predicate part 2> ::=
  <comp op>  <row value predicand> 

<comp op> ::=
    <equals operator> 
  | <not equals operator> 
  | <less than operator> 
  | <greater than operator> 
  | <less than or equals operator> 
  | <greater than or equals operator> 

<between predicate> ::=
  <row value predicand>  <between predicate part 2> 

<between predicate part 2> ::=
  [ NOT ] BETWEEN [ ASYMMETRIC | SYMMETRIC ]
      <row value predicand>  AND <row value predicand> 

<in predicate> ::=
  <row value predicand>  <in predicate part 2> 

<in predicate part 2> ::=
  [ NOT ] IN <in predicate value> 

<in predicate value> ::=
    <table subquery> 
  | <left paren>  <in value list>  <right paren> 

<in value list> ::=
  <row value expression>  [ { <comma>  <row value expression>  }... ]

<like predicate> ::=
    <character like predicate> 
  | <octet like predicate> 

<character like predicate> ::=
  <row value predicand>  <character like predicate part 2> 

<character like predicate part 2> ::=
  [ NOT ] LIKE <character pattern>  [ ESCAPE <escape character>  ]

<character pattern> ::=
  <character value expression> 

<escape character> ::=
  <character value expression> 

<octet like predicate> ::=
  <row value predicand>  <octet like predicate part 2> 

<octet like predicate part 2> ::=
  [ NOT ] LIKE <octet pattern>  [ ESCAPE <escape octet>  ]

<octet pattern> ::=
  <binary value expression> 

<escape octet> ::=
  <binary value expression> 

<similar predicate> ::=
  <row value predicand>  <similar predicate part 2> 

<similar predicate part 2> ::=
  [ NOT ] SIMILAR TO <similar pattern>  [ ESCAPE <escape character>  ]

<similar pattern> ::=
  <character value expression> 

<regular expression> ::=
    <regular term> 
  | <regular expression>  <vertical bar>  <regular term> 

<regular term> ::=
    <regular factor> 
  | <regular term>  <regular factor> 

<regular factor> ::=
    <regular primary> 
  | <regular primary>       <asterisk> 
  | <regular primary>       <plus sign> 
  | <regular primary>       <question mark> 
  | <regular primary>       <repeat factor> 

<repeat factor> ::=
  <left brace>  <low value>  [ <upper limit>  ] <right brace> 

<upper limit> ::=
  <comma>  [ <high value>  ]

<low value> ::=
  <unsigned integer> 

<high value> ::=
  <unsigned integer> 

<regular primary> ::=
    <character specifier> 
  | <percent> 
  | <regular character set> 
  | <left paren>  <regular expression>  <right paren> 

<character specifier> ::=
    <non-escaped character> 
  | <escaped character> 

<non-escaped character> ::=
  !! See the Syntax Rules.

<escaped character> ::=
  !! See the Syntax Rules.

<regular character set> ::=
    <underscore> 
  | <left bracket>  <character enumeration> ... <right bracket> 
  | <left bracket>  <circumflex>  <character enumeration> ... <right bracket> 
  | <left bracket>  <character enumeration include> ...
      <circumflex>  <character enumeration exclude> ... <right bracket> 

<character enumeration include> ::=
  <character enumeration> 

<character enumeration exclude> ::=
  <character enumeration> 

<character enumeration> ::=
    <character specifier> 
  | <character specifier>  <minus sign>  <character specifier> 
  | <left bracket>  <colon>  <regular character set identifier>  <colon>  <right bracket> 

<regular character set identifier> ::=
  <identifier> 

<regex like predicate> ::=
  <row value predicand>  <regex like predicate part 2> 

<regex like predicate part 2> ::=
  [ NOT ] LIKE_REGEX <XQuery pattern>  [ FLAG <XQuery option flag>  ]

<null predicate> ::=
  <row value predicand>  <null predicate part 2> 

<null predicate part 2> ::=
  IS [ NOT ] NULL

<quantified comparison predicate> ::=
  <row value predicand>  <quantified comparison predicate part 2> 

<quantified comparison predicate part 2> ::=
  <comp op>  <quantifier>  <table subquery> 

<quantifier> ::=
    <all> 
  | <some> 

<all> ::=
  ALL

<some> ::=
    SOME
  | ANY

<exists predicate> ::=
  EXISTS <table subquery> 

<unique predicate> ::=
  UNIQUE <table subquery> 

<normalized predicate> ::=
  <row value predicand>  <normalized predicate part 2> 

<normalized predicate part 2> ::=
  IS [ NOT ] [ <normal form>  ] NORMALIZED

<match predicate> ::=
  <row value predicand>  <match predicate part 2> 

<match predicate part 2> ::=
  MATCH [ UNIQUE ] [ SIMPLE | PARTIAL | FULL ] <table subquery> 

<overlaps predicate> ::=
  <overlaps predicate part 1>  <overlaps predicate part 2> 

<overlaps predicate part 1> ::=
  <row value predicand 1> 

<overlaps predicate part 2> ::=
  OVERLAPS <row value predicand 2> 

<row value predicand 1> ::=
  <row value predicand> 

<row value predicand 2> ::=
  <row value predicand> 

<distinct predicate> ::=
  <row value predicand 3>  <distinct predicate part 2> 

<distinct predicate part 2> ::=
  IS [ NOT ] DISTINCT FROM <row value predicand 4> 

<row value predicand 3> ::=
  <row value predicand> 

<row value predicand 4> ::=
  <row value predicand> 

<member predicate> ::=
  <row value predicand>  <member predicate part 2> 

<member predicate part 2> ::=
  [ NOT ] MEMBER [ OF ] <multiset value expression> 

<submultiset predicate> ::=
  <row value predicand>  <submultiset predicate part 2> 

<submultiset predicate part 2> ::=
  [ NOT ] SUBMULTISET [ OF ] <multiset value expression> 

<set predicate> ::=
  <row value predicand>  <set predicate part 2> 

<set predicate part 2> ::=
  IS [ NOT ] A SET

<type predicate> ::=
  <row value predicand>  <type predicate part 2> 

<type predicate part 2> ::=
  IS [ NOT ] OF <left paren>  <type list>  <right paren> 

<type list> ::=
  <user-defined type specification> 
      [ { <comma>  <user-defined type specification>  }... ]

<user-defined type specification> ::=
    <inclusive user-defined type specification> 
  | <exclusive user-defined type specification> 

<inclusive user-defined type specification> ::=
  <path-resolved user-defined type name> 

<exclusive user-defined type specification> ::=
  ONLY <path-resolved user-defined type name> 

<period predicate> ::=
    <period overlaps predicate> 
  | <period equals predicate> 
  | <period contains predicate> 
  | <period precedes predicate> 
  | <period succeeds predicate> 
  | <period immediately precedes predicate> 
  | <period immediately succeeds predicate> 

<period overlaps predicate> ::=
  <period predicand 1>  <period overlaps predicate part 2> 

<period overlaps predicate part 2> ::=
  OVERLAPS <period predicand 2> 

<period predicand 1> ::=
  <period predicand> 

<period predicand 2> ::=
  <period predicand> 

<period predicand> ::=
    <period reference> 
  | PERIOD <left paren>  <period start value>  <comma>  <period end value>  <right paren> 

<period reference> ::=
  <basic identifier chain> 

<period start value> ::=
  <datetime value expression> 

<period end value> ::=
  <datetime value expression> 

<period equals predicate> ::=
  <period predicand 1>  <period equals predicate part 2> 

<period equals predicate part 2> ::=
  EQUALS <period predicand 2> 

<period contains predicate> ::=
  <period predicand 1>  <period contains predicate part 2> 

<period contains predicate part 2> ::=
  CONTAINS <period or point-in-time predicand> 

<period or point-in-time predicand> ::=
    <period predicand> 
  | <datetime value expression> 

<period precedes predicate> ::=
  <period predicand 1>  <period precedes predicate part 2> 

<period precedes predicate part 2> ::=
  PRECEDES <period predicand 2> 

<period succeeds predicate> ::=
  <period predicand 1>  <period succeeds predicate part 2> 

<period succeeds predicate part 2> ::=
  SUCCEEDS <period predicand 2> 

<period immediately precedes predicate> ::=
  <period predicand 1>  <period immediately precedes predicate part 2> 

<period immediately precedes predicate part 2> ::=
  IMMEDIATELY PRECEDES <period predicand 2> 

<period immediately succeeds predicate> ::=
  <period predicand 1>  <period immediately succeeds predicate part 2> 

<period immediately succeeds predicate part 2> ::=
  IMMEDIATELY SUCCEEDS <period predicand 2> 

<search condition> ::=
  <boolean value expression> 

<JSON predicate> ::=
  <string value expression>  [ <JSON input clause>  ]
      IS [ NOT ] JSON
      [ <JSON predicate type constraint>  ]
      [ <JSON key uniqueness constraint>  ]

<JSON predicate type constraint> ::=
    VALUE
  | ARRAY
  | OBJECT
  | SCALAR

<JSON key uniqueness constraint> ::=
    WITH UNIQUE [ KEYS ]
  | WITHOUT UNIQUE [ KEYS ]

<JSON exists predicate> ::=
  JSON_EXISTS <left paren> 
      <JSON API common syntax> 
      [ <JSON exists error behavior>  ON ERROR ]
  <right paren> 

<JSON exists error behavior> ::=
  TRUE | FALSE | UNKNOWN | ERROR

<SQL/JSON special symbol> ::=
    <asterisk> 
  | <at sign> 
  | <comma> 
  | <dollar sign> 
  | <double ampersand> 
  | <double equals> 
  | <double vertical bar> 
  | <exclamation mark> 
  | <greater than operator> 
  | <greater than or equals operator> 
  | <left bracket> 
  | <left paren> 
  | <less than operator> 
  | <less than or equals operator> 
  | <minus sign> 
  | <not equals operator> 
  | <percent> 
  | <period> 
  | <plus sign> 
  | <question mark> 
  | <right bracket> 
  | <right paren> 
  | <solidus> 

<at sign> ::=
  @

<double ampersand> ::=
  &&

<double equals> ::=
  ==

<double vertical bar> ::=
  ||

<exclamation mark> ::=
  !

<SQL/JSON key word> ::=
    abs
  | ceiling
  | datetime
  | double
  | exists
  | false
  |   flag
  |   floor
  |   is
  |   keyvalue
  |   last
  |   lax
  |   like_regex
  |   null
  |   size
  |   starts
  |   strict
  |   to
  |   true
  |   type
  |   unknown
  |   with

<JSON path literal> ::=
  !! See the Syntax Rules.

<JSON path string literal> ::=
  !! See the Syntax Rules.

<JSON path numeric literal> ::=
  !! See the Syntax Rules.

<JSON path identifier> ::=
  !! See the Syntax Rules.

<JSON path context variable> ::=
  !! See the Syntax Rules.

<JSON path named variable> ::=
  !! See the Syntax Rules.

<JSON path key name> ::=
  !! See the Syntax Rules.

<JSON path expression> ::=
  <JSON path mode>  <JSON path wff> 

<JSON path mode> ::=
  strict | lax

<JSON path primary> ::=
    <JSON path literal> 
  | <JSON path variable> 
  | <left paren>  <JSON path wff>  <right paren> 

<JSON path variable> ::=
    <JSON path context variable> 
  | <JSON path named variable> 
  | <at sign> 
  | <JSON last subscript> 

<JSON path context variable> ::=
  <dollar sign> 

<JSON path named variable> ::=
  <dollar sign>  <JSON path identifier> 

<JSON last subscript> ::=
  last

<JSON accessor expression> ::=
    <JSON path primary> 
  | <JSON accessor expression>  <JSON accessor op> 

<JSON accessor op> ::=
      <JSON    member accessor> 
  |   <JSON    wildcard member accessor> 
  |   <JSON    array accessor> 
  |   <JSON    wildcard array accessor> 
  |   <JSON    filter expression> 
  |   <JSON    item method> 

<JSON member accessor> ::=
    <period>  <JSON path key name> 
  | <period>  <JSON path string literal> 
      NOTE 447 - Unlike [ECMAScript], SQL/JSON path language does not provide a member accessor using brackets that enclose
      a character string.

<JSON wildcard member accessor> ::=
  <period>  <asterisk> 

<JSON array accessor> ::=
  <left bracket>  <JSON subscript list>  <right bracket> 

<JSON subscript list> ::=
  <JSON subscript>  [ { <comma>  <JSON subscript>  }... ]

<JSON subscript> ::=
    <JSON path wff 1> 
  | <JSON path wff 2>  to <JSON path wff 3> 

<JSON path wff 1> ::=
  <JSON path wff> 

<JSON path wff 2> ::=
  <JSON path wff> 

<JSON path wff 3> ::=
  <JSON path wff> 

<JSON wildcard array accessor> ::=
  <left bracket>  <asterisk>  <right bracket> 

<JSON filter expression> ::=
  <question mark>  <left paren>  <JSON path predicate>  <right paren> 
      NOTE 448 - Unlike [ECMAScript], predicates are not expressions; instead they form a separate language that can only be invoked
      within a <JSON filter expression> .

<JSON item method> ::=
  <period>  <JSON method> 

<JSON method> ::=
    type <left paren>  <right paren> 
  | size <left paren>  <right paren> 
  | double <left paren>  <right paren> 
  | ceiling <left paren>  <right paren> 
  | floor <left paren>  <right paren> 
  | abs <left paren>  <right paren> 
  | datetime <left paren>  [ <JSON datetime template>  ] <right paren> 
  | keyvalue <left paren>  <right paren> 

<JSON datetime template> ::=
  <JSON path string literal> 
<JSON unary expression> ::=
    <JSON accessor expression> 
  | <plus sign>  <JSON unary expression> 
  | <minus sign>  <JSON unary expression> 

<JSON multiplicative expression> ::=
    <JSON unary expression> 
  | <JSON multiplicative expression>  <asterisk>  <JSON unary expression> 
  | <JSON multiplicative expression>  <solidus>  <JSON unary expression> 
  | <JSON multiplicative expression>  <percent>  <JSON unary expression> 

<JSON additive expression> ::=
    <JSON multiplicative expression> 
  | <JSON additive expression>  <plus sign>  <JSON multiplicative expression> 
  | <JSON additive expression>  <minus sign>  <JSON multiplicative expression> 

<JSON path wff> ::=
  <JSON additive expression> 
   NOTE 449 - This concludes the main language for JSON path expressions. Next comes the language for predicates, used only
   in <JSON filter expression> .

<JSON predicate primary> ::=
    <JSON delimited predicate> 
  | <JSON non-delimited predicate> 

<JSON delimited predicate> ::=
    <JSON exists path predicate> 
  | <left paren>  <JSON path predicate>  <right paren> 

<JSON non-delimited predicate> ::=
    <JSON comparison predicate> 
  | <JSON like_regex predicate> 
  | <JSON starts with predicate> 
  | <JSON unknown predicate> 

<JSON exists path predicate> ::=
  exists <left paren>  <JSON path wff>  <right paren> 

<JSON comparison predicate> ::=
  <JSON path wff>  <JSON comp op>  <JSON path wff> 
   NOTE 450 - Comparison operators are not left associative, unlike [ECMAScript].

<JSON comp op> ::=
    <double equals> 
  | <not equals operator> 
  | <less than operator> 
  | <greater than operator> 
  | <less than or equals operator> 
  | <greater than or equals operator> 
   NOTE 451 - Equality operators have the same precedence as inequality comparison operators, unlike [ECMAScript].

<JSON like_regex predicate> ::=
  <JSON path wff>  like_regex <JSON like_regex pattern> 
      [ flag <JSON like_regex flags>  ]

<JSON like_regex pattern> ::=
  <JSON path string literal> 
<JSON like_regex flags> ::=
  <JSON path string literal> 

<JSON starts with predicate> ::=
  <JSON starts with whole>  starts with <JSON starts with initial> 

<JSON starts with whole> ::=
  <JSON path wff> 

<JSON starts with initial> ::=
    <JSON path string literal> 
  | <JSON path named variable> 

<JSON unknown predicate> ::=
  <left paren>  <JSON path predicate>  <right paren>  is unknown

<JSON boolean negation> ::=
    <JSON predicate primary> 
  | <exclamation mark>  <JSON delimited predicate> 

<JSON boolean conjunction> ::=
    <JSON boolean negation> 
  | <JSON boolean conjunction>  <double ampersand>  <JSON boolean negation> 

<JSON boolean disjunction> ::=
    <JSON boolean conjunction> 
  | <JSON boolean disjunction>  <double vertical bar>  <JSON boolean conjunction> 

<JSON path predicate> ::=
  <JSON boolean disjunction> 

<datetime template> ::=
  { <datetime template part>  }...

<datetime template part> ::=
    <datetime template field> 
  | <datetime template delimiter> 

<datetime template field> ::=
    <datetime template year> 
  | <datetime template rounded year> 
  | <datetime template month> 
  | <datetime template day of month> 
  | <datetime template day of year> 
  | <datetime template 12-hour> 
  | <datetime template 24-hour> 
  | <datetime template minute> 
  | <datetime template second of minute> 
  | <datetime template second of day> 
  | <datetime template fraction> 
  | <datetime template am/pm> 
  | <datetime template time zone hour> 
  | <datetime template time zone minute> 

<datetime template delimiter> ::=
    <minus sign> 
  | <period> 
  | <solidus> 
  | <comma> 
  | <apostrophe> 
  | <semicolon> 
  | <colon> 
  | <space> 

<datetime template year> ::=
  YYYY | YYY | YY | Y

<datetime template rounded year> ::=
  RRRR | RR
<datetime template month> ::=
  MM

<datetime template day of month> ::=
  DD

<datetime template day of year> ::=
  DDD

<datetime template 12-hour> ::=
  HH | HH12

<datetime template 24-hour> ::=
  HH24

<datetime template minute> ::=
  MI

<datetime template second of minute> ::=
  SS

<datetime template second of day> ::=
  SSSSS

<datetime template fraction> ::=
  FF1 | FF2 | FF3 | FF4 | FF5 | FF6 | FF7 | FF8 | FF9

<datetime template am/pm> ::=
  A.M. | P.M.

<datetime template time zone hour> ::=
  TZH

<datetime template time zone minute> ::=
  TZM

<interval qualifier> ::=
    <start field>  TO <end field> 
  | <single datetime field> 

<start field> ::=
  <non-second primary datetime field> 
      [ <left paren>  <interval leading field precision>  <right paren>  ]

<end field> ::=
    <non-second primary datetime field> 
  | SECOND [ <left paren>  <interval fractional seconds precision>  <right paren>  ]

<single datetime field> ::=
    <non-second primary datetime field> 
        [ <left paren>  <interval leading field precision>  <right paren>  ]
  | SECOND [ <left paren>  <interval leading field precision> 
      [ <comma>  <interval fractional seconds precision>  ] <right paren>  ]

<primary datetime field> ::=
    <non-second primary datetime field> 
  | SECOND

<non-second primary datetime field> ::=
    YEAR
  | MONTH
  | DAY
  | HOUR
  | MINUTE

<interval fractional seconds precision> ::=
  <unsigned integer> 

<interval leading field precision> ::=
  <unsigned integer> 

<language clause> ::=
  LANGUAGE <language name> 

<language name> ::=
    ADA
  | C
  | COBOL
  | FORTRAN
  | M | MUMPS
  | PASCAL
  | PLI
  | SQL

<path specification> ::=
  PATH <schema name list> 

<schema name list> ::=
  <schema name>  [ { <comma>  <schema name>  }... ]

<routine invocation> ::=
  <routine name>  <SQL argument list> 

<routine name> ::=
  [ <schema name>  <period>  ] <qualified identifier> 

<SQL argument list> ::=
  <left paren> 
      [ <SQL argument>  [ { <comma>  <SQL argument>  }... ] [ <copartition clause>  ] ]
      <right paren> 

<SQL argument> ::=
    <value expression> 
  | <generalized expression> 
  | <target specification> 
  | <contextually typed value specification> 
  | <named argument specification> 
  | <table argument> 
  | <descriptor argument> 

<generalized expression> ::=
  <value expression>  AS <path-resolved user-defined type name> 

<named argument specification> ::=
  <SQL parameter name>  <named argument assignment token> 
      <named argument SQL argument> 

<named argument SQL argument> ::=
    <value expression> 
  | <target specification> 
  | <contextually typed value specification> 
  | <table argument> 
  | <descriptor argument> 

<table argument> ::=
  <table argument proper> 
      [ [ AS ] <table argument correlation name> 
      [ <table argument parenthesized derived column list>  ] ]
      [ <table argument partitioning>  ]
      [ <table argument pruning>  ]
      [ <table argument ordering>  ]

<table argument correlation name> ::=
  <correlation name> 

<table argument parenthesized derived column list> ::=
  <parenthesized derived column list> 

<table argument proper> ::=
    TABLE <left paren>  <table or query name>  <right paren> 
  | TABLE <table subquery> 
  | <table function invocation> 

<table function invocation> ::=
  <routine invocation> 

<table argument partitioning> ::=
  PARTITION BY <table argument partitioning list> 

<table argument partitioning list> ::=
    <column reference> 
  | <left paren>  [ <column reference>  [ { <comma>  <column reference>  }... ] ] <right paren> 

<table argument pruning> ::=
    PRUNE WHEN EMPTY
  | KEEP WHEN EMPTY

<table argument ordering> ::=
  ORDER BY <table argument ordering list> 

<table argument ordering list> ::=
    <table argument ordering column> 
  | <left paren> 
      <table argument ordering column> 
      [ { <comma>  <table argument ordering column>  }... ]
      <right paren> 

<table argument ordering column> ::=
  <column reference>  [ <ordering specification>  ] [ <null ordering>  ]

<copartition clause> ::=
  COPARTITION <copartition list> 

<copartition list> ::=
  <copartition specification>  [ { <comma>  <copartition specification>  }... ]

<copartition specification> ::=
  <left paren>  <range variable>  <comma>  <range variable> 
      [ { <comma>  <range variable>  }... ] <right paren> 

<range variable> ::=
    <table name> 
  | <query name> 
  | <correlation name> 

<descriptor argument> ::=
    <descriptor value constructor> 
  | CAST <left paren>  NULL AS DESCRIPTOR <right paren> 

<character set specification> ::=
    <standard character set name> 
  | <implementation-defined character set name> 
  | <user-defined character set name> 

<standard character set name> ::=
  <character set name> 

<implementation-defined character set name> ::=
  <character set name> 

<user-defined character set name> ::=
  <character set name> 

<specific routine designator> ::=
    SPECIFIC <routine type>  <specific name> 
  | <routine type>  <member name>  [ FOR <schema-resolved user-defined type name>  ]

<routine type> ::=
    ROUTINE
  | FUNCTION
  | PROCEDURE
  | [ INSTANCE | STATIC | CONSTRUCTOR ] METHOD

<member name> ::=
  <member name alternatives>  [ <data type list>  ]

<member name alternatives> ::=
    <schema qualified routine name> 
  | <method name> 

<data type list> ::=
  <left paren>  [ <data type>  [ { <comma>  <data type>  }... ] ] <right paren> 

<collate clause> ::=
  COLLATE <collation name> 

<constraint name definition> ::=
  CONSTRAINT <constraint name> 

<constraint characteristics> ::=
    <constraint check time>  [ [ NOT ] DEFERRABLE ] [ <constraint enforcement>  ]
  | [ NOT ] DEFERRABLE [ <constraint check time>  ] [ <constraint enforcement>  ]
  | <constraint enforcement> 

<constraint check time> ::=
    INITIALLY DEFERRED
  | INITIALLY IMMEDIATE

<constraint enforcement> ::=
  [ NOT ] ENFORCED

<aggregate function> ::=
    COUNT <left paren>  <asterisk>  <right paren>  [ <filter clause>  ]
  | <general set function>  [ <filter clause>  ]
  | <binary set function>  [ <filter clause>  ]
  | <ordered set function>  [ <filter clause>  ]
  | <array aggregate function>  [ <filter clause>  ]
  | <row pattern count function>  [ <filter clause>  ]
  | <JSON aggregate function>  [ <filter clause>  ]

<general set function> ::=
  <set function type>  <left paren>  [ <set quantifier>  ]
      <value expression>  <right paren> 

<set function type> ::=
  <computational operation> 

<computational operation> ::=
    AVG
  | MAX
  | MIN
  | SUM
  | EVERY
  | ANY
  | SOME
  | COUNT
  | STDDEV_POP
  | STDDEV_SAMP
  | VAR_SAMP
  | VAR_POP
  | COLLECT
  | FUSION
  | INTERSECTION

<set quantifier> ::=
    DISTINCT
  | ALL

<filter clause> ::=
  FILTER <left paren>  WHERE <search condition>  <right paren> 

<binary set function> ::=
  <binary set function type>  <left paren>  <dependent variable expression>  <comma> 
      <independent variable expression>  <right paren> 

<binary set function type> ::=
    COVAR_POP
  | COVAR_SAMP
  | CORR
  | REGR_SLOPE
  | REGR_INTERCEPT
  | REGR_COUNT
  | REGR_R2
  | REGR_AVGX
  | REGR_AVGY
  | REGR_SXX
  | REGR_SYY
  | REGR_SXY

<dependent variable expression> ::=
  <numeric value expression> 

<independent variable expression> ::=
  <numeric value expression> 

<ordered set function> ::=
    <hypothetical set function> 
  | <inverse distribution function> 
  | <listagg set function> 

<hypothetical set function> ::=
  <rank function type>  <left paren> 
      <hypothetical set function value expression list>  <right paren> 
      <within group specification> 

<within group specification> ::=
  WITHIN GROUP <left paren>  ORDER BY <sort specification list>  <right paren> 

<hypothetical set function value expression list> ::=
  <value expression>  [ { <comma>  <value expression>  }... ]

<inverse distribution function> ::=
  <inverse distribution function type>  <left paren> 
      <inverse distribution function argument>  <right paren> 
      <within group specification> 

<inverse distribution function argument> ::=
  <numeric value expression> 

<inverse distribution function type> ::=
    PERCENTILE_CONT
  | PERCENTILE_DISC

<listagg set function> ::=
  LISTAGG <left paren>  [ <set quantifier>  ] <character value expression> 
      <comma>  <listagg separator>  [ <listagg overflow clause>  ] <right paren> 
      <within group specification> 

<listagg separator> ::=
  <character string literal> 

<listagg overflow clause> ::=
  ON OVERFLOW <overflow behavior> 

<overflow behavior> ::=
    ERROR
  | TRUNCATE [ <listagg truncation filler>  ] <listagg count indication> 

<listagg truncation filler> ::=
  <character string literal> 

<listagg count indication> ::=
    WITH COUNT>
  | WITHOUT COUNT>

<array aggregate function> ::=
  ARRAY_AGG
      <left paren>  <value expression>  [ ORDER BY <sort specification list>  ] <right paren> 

<row pattern count function> ::=
  COUNT <left paren>  <row pattern variable name>  <period>  <asterisk>  <right paren> 

<sort specification list> ::=
  <sort specification>  [ { <comma>  <sort specification>  }... ]

<sort specification> ::=
  <sort key>  [ <ordering specification>  ] [ <null ordering>  ]

<sort key> ::=
  <value expression> 

<ordering specification> ::=
    ASC
  | DESC

<null ordering> ::=
    NULLS FIRST
  | NULLS LAST

<JSON aggregate function> ::=
    <JSON object aggregate constructor> 
  | <JSON array aggregate constructor> 

<JSON object aggregate constructor> ::=
  JSON_OBJECTAGG <left paren> 
      <JSON name and value> 
      [ <JSON constructor null clause>  ]
      [ <JSON key uniqueness constraint>  ]
      [ <JSON output clause>  ]
      <right paren> 

<JSON array aggregate constructor> ::=
  JSON_ARRAYAGG <left paren> 
      <JSON value expression> 
      [ <JSON array aggregate order by clause>  ]
      [ <JSON constructor null clause>  ]
      [ <JSON output clause>  ]
      <right paren> 

<JSON array aggregate order by clause> ::=
  ORDER BY <sort specification list> 

<JSON value expression> ::=
  <value expression>  [ <JSON input clause>  ]

<JSON input clause> ::=
  FORMAT <JSON representation> 

<JSON output clause> ::=
  RETURNING <data type>  [ FORMAT <JSON representation>  ]

<JSON representation> ::=
    JSON [ ENCODING { UTF8 | UTF16 | UTF32 } ]
  | <implementation-defined JSON representation option> 

<implementation-defined JSON representation option> ::=
  !! See the Syntax Rules.

<JSON API common syntax> ::=
  <JSON context item>  <comma>  <JSON path specification>  [ AS <JSON table path name>  ]
      [ <JSON passing clause>  ]

<JSON context item> ::=
  <JSON value expression> 

<JSON path specification> ::=
  <character string literal> 

<JSON passing clause> ::=
  PASSING <JSON argument>  [ { <comma>  <JSON argument>  }... ]

<JSON argument> ::=
  <JSON value expression>  AS <identifier> 

<schema definition> ::=
  CREATE SCHEMA <schema name clause> 
      [ <schema character set or path>  ]
      [ <schema element> ... ]

<schema character set or path> ::=
    <schema character set specification> 
  | <schema path specification> 
  | <schema character set specification>  <schema path specification> 
  | <schema path specification>  <schema character set specification> 

<schema name clause> ::=
    <schema name> 
  | AUTHORIZATION <schema authorization identifier> 
  | <schema name>  AUTHORIZATION <schema authorization identifier> 

<schema authorization identifier> ::=
  <authorization identifier> 

<schema character set specification> ::=
  DEFAULT CHARACTER SET <character set specification> 

<schema path specification> ::=
  <path specification> 

<schema element> ::=
      <table definition> 
  |   <view definition> 
  |   <domain definition> 
  |   <character set definition> 
  |   <collation definition> 
  |   <transliteration definition> 
  |   <assertion definition> 
  |   <trigger definition> 
  |   <user-defined type definition> 
  |   <user-defined cast definition> 
  |   <user-defined ordering definition> 
  |   <transform definition> 
  |   <schema routine> 
  |   <sequence generator definition> 
  |   <grant statement> 
  |   <role definition> 

<drop schema statement> ::=
  DROP SCHEMA <schema name>  <drop behavior> 

<drop behavior> ::=
    CASCADE
  | RESTRICT

<table definition> ::=
  CREATE [ <table scope>  ] TABLE <table name>  <table contents source> 
      [ WITH <system versioning clause>  ]
      [ ON COMMIT <table commit action>  ROWS ]

<table contents source> ::=
    <table element list> 
  | <typed table clause> 
  | <as subquery clause> 

<table scope> ::=
  <global or local>  TEMPORARY

<global or local> ::=
    GLOBAL
  | LOCAL

<system versioning clause> ::=
  SYSTEM VERSIONING

<table commit action> ::=
    PRESERVE
  | DELETE

<table element list> ::=
  <left paren>  <table element>  [ { <comma>  <table element>  }... ] <right paren> 

<table element> ::=
    <column definition> 
  | <table period definition> 
  | <table constraint definition> 
  | <like clause> 

<typed table clause> ::=
  OF <path-resolved user-defined type name>  [ <subtable clause>  ]
      [ <typed table element list>  ]

<typed table element list> ::=
  <left paren>  <typed table element> 
      [ { <comma>  <typed table element>  }... ] <right paren> 

<typed table element> ::=
    <column options> 
  | <table constraint definition> 
  | <self-referencing column specification> 

<self-referencing column specification> ::=
  REF IS <self-referencing column name>  [ <reference generation>  ]

<reference generation> ::=
    SYSTEM GENERATED
  | USER GENERATED
  | DERIVED

<self-referencing column name> ::=
  <column name> 

<column options> ::=
  <column name>  WITH OPTIONS <column option list> 

<column option list> ::=
  [ <scope clause>  ] [ <default clause>  ] [ <column constraint definition> ... ]

<subtable clause> ::=
  UNDER <supertable clause> 

<supertable clause> ::=
  <supertable name> 

<supertable name> ::=
  <table name> 

<like clause> ::=
  LIKE <table name>  [ <like options>  ]

<like options> ::=
  <like option> ...

<like option> ::=
    <identity option> 
  | <column default option> 
  | <generation option> 

<identity option> ::=
    INCLUDING IDENTITY
  | EXCLUDING IDENTITY

<column default option> ::=
    INCLUDING DEFAULTS
  | EXCLUDING DEFAULTS

<generation option> ::=
    INCLUDING GENERATED
  | EXCLUDING GENERATED

<as subquery clause> ::=
  [ <left paren>  <column name list>  <right paren>  ] AS <table subquery> 
      <with or without data> 

<with or without data> ::=
    WITH NO DATA
  | WITH DATA

<table period definition> ::=
  <system or application time period specification> 
      <left paren>  <period begin column name>  <comma>  <period end column name>  <right paren> 

<system or application time period specification> ::=
    <system time period specification> 
  | <application time period specification> 

<system time period specification> ::=
  PERIOD FOR SYSTEM_TIME

<application time period specification> ::=
  PERIOD FOR <application time period name> 

<application time period name> ::=
  <identifier> 

<period begin column name> ::=
  <column name> 

<period end column name> ::=
  <column name> 

<column definition> ::=
  <column name>  [ <data type or domain name>  ]
      [ <default clause>  | <identity column specification>  | <generation clause> 
      | <system time period start column specification> 
      | <system time period end column specification>  ]
      [ <column constraint definition> ... ]
      [ <collate clause>  ]

<data type or domain name> ::=
    <data type> 
  | <domain name> 

<system time period start column specification> ::=
  <timestamp generation rule>  AS ROW START

<system time period end column specification> ::=
  <timestamp generation rule>  AS ROW END

<timestamp generation rule> ::=
  GENERATED ALWAYS

<column constraint definition> ::=
  [ <constraint name definition>  ] <column constraint>  [ <constraint characteristics>  ]

<column constraint> ::=
    NOT NULL
  | <unique specification> 
  | <references specification> 
  | <check constraint definition> 

<identity column specification> ::=
  GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY
      [ <left paren>  <common sequence generator options>  <right paren>  ]

<generation clause> ::=
  <generation rule>  AS <generation expression> 

<generation rule> ::=
  GENERATED ALWAYS

<generation expression> ::=
  <left paren>  <value expression>  <right paren> 

<default clause> ::=
  DEFAULT <default option> 

<default option> ::=
    <literal> 
  | <datetime value function> 
  | USER
  | CURRENT_USER
  | CURRENT_ROLE
  | SESSION_USER
  | SYSTEM_USER
  | CURRENT_CATALOG
  | CURRENT_SCHEMA
  | CURRENT_PATH
  | <implicitly typed value specification> 

<table constraint definition> ::=
  [ <constraint name definition>  ] <table constraint> 
      [ <constraint characteristics>  ]

<table constraint> ::=
    <unique constraint definition> 
  | <referential constraint definition> 
  | <check constraint definition> 

<unique constraint definition> ::=
    <unique specification>  <left paren>  <unique column list>  [ <comma>  <without overlap specification>  ] <right paren> 
  | UNIQUE ( VALUE )

<unique specification> ::=
    UNIQUE
  | PRIMARY KEY

<unique column list> ::=
  <column name list> 

<without overlap specification> ::=
  <application time period name>  WITHOUT OVERLAPS

<referential constraint definition> ::=
  FOREIGN KEY <left paren>  <referencing column list> 
      [ <comma>  <referencing period specification>  ] <right paren> 
      <references specification> 

<references specification> ::=
  REFERENCES <referenced table and columns> 
      [ MATCH <match type>  ] [ <referential triggered action>  ]

<match type> ::=
    FULL
  | PARTIAL
  | SIMPLE

<referencing column list> ::=
  <column name list> 

<referencing period specification> ::=
  PERIOD <application time period name> 

<referenced table and columns> ::=
  <table name>  [ <left paren>  <referenced column list> 
      [ <comma>  <referenced period specification>  ] <right paren>  ]

<referenced column list> ::=
  <column name list> 

<referenced period specification> ::=
  PERIOD <application time period name> 

<referential triggered action> ::=
    <update rule>  [ <delete rule>  ]
  | <delete rule>  [ <update rule>  ]

<update rule> ::=
  ON UPDATE <referential action> 

<delete rule> ::=
  ON DELETE <referential action> 

<referential action> ::=
    CASCADE
  | SET NULL
  | SET DEFAULT
  | RESTRICT
  | NO ACTION

<check constraint definition> ::=
     CHECK <left paren>  <search condition>  <right paren> 

<alter table statement> ::=
  ALTER TABLE <table name>  <alter table action> 

<alter table action> ::=
    <add column definition> 
  | <alter column definition> 
  | <drop column definition> 
  | <add table constraint definition> 
  | <alter table constraint definition> 
  | <drop table constraint definition> 
  | <add table period definition> 
  | <drop table period definition> 
  | <add system versioning clause> 
  | <drop system versioning clause> 

<add column definition> ::=
  ADD [ COLUMN ] <column definition> 

<alter column definition> ::=

<alter column action> ::=
    <set column default clause> 
  | <drop column default clause> 
  | <set column not null clause> 
  | <drop column not null clause> 
  | <add column scope clause> 
  | <drop column scope clause> 
  | <alter column data type clause> 
  | <alter identity column specification> 
  | <drop identity property clause> 
  | <drop column generation expression clause> 

<set column default clause> ::=
  SET <default clause> 

<drop column default clause> ::=
  DROP DEFAULT

<set column not null clause> ::=
  SET NOT NULL

<drop column not null clause> ::=
  DROP NOT NULL

<add column scope clause> ::=
  ADD <scope clause> 

<drop column scope clause> ::=
  DROP SCOPE <drop behavior> 

<alter column data type clause> ::=
  SET DATA TYPE <data type> 

<alter identity column specification> ::=
    <set identity column generation clause>  [ <alter identity column option> ... ]
  | <alter identity column option> ...

<set identity column generation clause> ::=
  SET GENERATED { ALWAYS | BY DEFAULT }

<alter identity column option> ::=
    <alter sequence generator restart option> 
  | SET <basic sequence generator option> 

<drop identity property clause> ::=
  DROP IDENTITY

<drop column generation expression clause> ::=
  DROP EXPRESSION

<drop column definition> ::=
  DROP [ COLUMN ] <column name>  <drop behavior> 

<add table constraint definition> ::=
  ADD <table constraint definition> 

<alter table constraint definition> ::=
  ALTER CONSTRAINT <constraint name>  <constraint enforcement> 

<drop table constraint definition> ::=
  DROP CONSTRAINT <constraint name>  <drop behavior> 

<add table period definition> ::=
  ADD <table period definition>  [ <add system time period column list>  ]

<add system time period column list> ::=
  ADD [ COLUMN ] <column definition 1>  ADD [ COLUMN ] <column definition 2> 

<column definition 1> ::=
  <column definition> 

<column definition 2> ::=
  <column definition> 

<drop table period definition> ::=
  DROP <system or application time period specification>  <drop behavior> 

<add system versioning clause> ::=
  ADD <system versioning clause> 

<drop system versioning clause> ::=
  DROP SYSTEM VERSIONING <drop behavior> 

<drop table statement> ::=
  DROP TABLE <table name>  <drop behavior> 

<view definition> ::=
  CREATE [ RECURSIVE ] VIEW <table name>  <view specification> 
      AS <query expression>  [ WITH [ <levels clause>  ] CHECK OPTION ]

<view specification> ::=
    <regular view specification> 
  | <referenceable view specification> 

<regular view specification> ::=
  [ <left paren>  <view column list>  <right paren>  ]

<referenceable view specification> ::=
  OF <path-resolved user-defined type name>  [ <subview clause>  ]
      [ <view element list>  ]

<subview clause> ::=
  UNDER <table name> 

<view element list> ::=
  <left paren>  <view element>  [ { <comma>  <view element>  }... ] <right paren> 

<view element> ::=
    <self-referencing column specification> 
  | <view column option> 

<view column option> ::=
  <column name>  WITH OPTIONS <scope clause> 

<levels clause> ::=
    CASCADED
  | LOCAL

<view column list> ::=
  <column name list> 

<drop view statement> ::=
  DROP VIEW <table name>  <drop behavior> 

<domain definition> ::=
  CREATE DOMAIN <domain name>  [ AS ] <predefined type> 
      [ <default clause>  ]
      [ <domain constraint> ... ]
      [ <collate clause>  ]

<domain constraint> ::=
  [ <constraint name definition>  ] <check constraint definition>  [
      <constraint characteristics>  ]

<alter domain statement> ::=
  ALTER DOMAIN <domain name>  <alter domain action> 

<alter domain action> ::=
    <set domain default clause> 
  | <drop domain default clause> 
  | <add domain constraint definition> 
  | <drop domain constraint definition> 

<set domain default clause> ::=
  SET <default clause> 

<drop domain default clause> ::=
  DROP DEFAULT

<add domain constraint definition> ::=
  ADD <domain constraint> 

<drop domain constraint definition> ::=
  DROP CONSTRAINT <constraint name> 

<drop domain statement> ::=
  DROP DOMAIN <domain name>  <drop behavior> 

<character set definition> ::=
  CREATE CHARACTER SET <character set name>  [ AS ]
      <character set source>  [ <collate clause>  ]

<character set source> ::=
  GET <character set specification> 

<drop character set statement> ::=
  DROP CHARACTER SET <character set name> 

<collation definition> ::=
  CREATE COLLATION <collation name>  FOR <character set specification> 
      FROM <existing collation name>  [ <pad characteristic>  ]

<existing collation name> ::=
  <collation name> 

<pad characteristic> ::=
    NO PAD
  | PAD SPACE

<drop collation statement> ::=
  DROP COLLATION <collation name>  <drop behavior> 

<transliteration definition> ::=
  CREATE TRANSLATION <transliteration name>  FOR <source character set specification> 
      TO <target character set specification>  FROM <transliteration source> 

<source character set specification> ::=
  <character set specification> 

<target character set specification> ::=
  <character set specification> 

<transliteration source> ::=
    <existing transliteration name> 
  | <transliteration routine> 

<existing transliteration name> ::=
  <transliteration name> 

<transliteration routine> ::=
  <specific routine designator> 

<drop transliteration statement> ::=
  DROP TRANSLATION <transliteration name> 

<assertion definition> ::=
     CREATE ASSERTION <constraint name> 
         CHECK <left paren>  <search condition>  <right paren> 
         [ <constraint characteristics>  ]

<drop assertion statement> ::=
  DROP ASSERTION <constraint name>  [ <drop behavior>  ]

<trigger definition> ::=
  CREATE TRIGGER <trigger name>  <trigger action time>  <trigger event> 
      ON <table name>  [ REFERENCING <transition table or variable list>  ]
      <triggered action> 

<trigger action time> ::=
    BEFORE
  | AFTER
  | INSTEAD OF

<trigger event> ::=
    INSERT
  | DELETE
  | UPDATE [ OF <trigger column list>  ]

<trigger column list> ::=
  <column name list> 

<triggered action> ::=
  [ FOR EACH { ROW | STATEMENT } ]
      [ <triggered when clause>  ]
      <triggered SQL statement> 

<triggered when clause> ::=
  WHEN <left paren>  <search condition>  <right paren> 

<triggered SQL statement> ::=
    <SQL procedure statement> 
  | BEGIN ATOMIC { <SQL procedure statement>  <semicolon>  }... END

<transition table or variable list> ::=
  <transition table or variable> ...

<transition table or variable> ::=
    OLD [ ROW ] [ AS ] <old transition variable name> 
  | NEW [ ROW ] [ AS ] <new transition variable name> 
  | OLD TABLE [ AS ] <old transition table name> 
  | NEW TABLE [ AS ] <new transition table name> 

<old transition table name> ::=
  <transition table name> 

<new transition table name> ::=
  <transition table name> 

<transition table name> ::=
  <identifier> 

<old transition variable name> ::=
  <correlation name> 

<new transition variable name> ::=
  <correlation name> 

<drop trigger statement> ::=
  DROP TRIGGER <trigger name> 

<user-defined type definition> ::=
  CREATE TYPE <user-defined type body> 

<user-defined type body> ::=
  <schema-resolved user-defined type name> 
      [ <subtype clause>  ]
      [ AS <representation>  ]
      [ <user-defined type option list>  ]
      [ <method specification list>  ]

<user-defined type option list> ::=
  <user-defined type option>  [ <user-defined type option> ... ]

<user-defined type option> ::=
    <instantiable clause> 
  | <finality> 
  | <reference type specification> 
  | <cast to ref> 
  | <cast to type> 
  | <cast to distinct> 
  | <cast to source> 

<subtype clause> ::=
  UNDER <supertype name> 

<supertype name> ::=
  <path-resolved user-defined type name> 

<representation> ::=
    <predefined type> 
  | <collection type> 
  | <member list> 

<member list> ::=
  <left paren>  <member>  [ { <comma>  <member>  }... ] <right paren> 

<member> ::=
  <attribute definition> 

<instantiable clause> ::=
    INSTANTIABLE
  | NOT INSTANTIABLE

<finality> ::=
    FINAL
  | NOT FINAL