The Perl Toolchain Summit needs more sponsors. If your company depends on Perl, please support this very important event.
### Based and converted from PostgreSQL's src/backend/parser/scan.l and ###
### src/interfaces/ecpg/preproc/parser.c                                ###

### Some comments retained from those sources, marked as #*.            ###

### FIXME: Rename Atoms to use C_* syntax ###

L_SPACE       : /[ \t\n\r\f]/
L_HORIZ_SPACE : /[ \t\f]/
L_NEWLINE     : /[\n\r]/
L_NON_NEWLINE : /[^\n\r]/

L_COMMENT     : / -- <L_NON_NEWLINE>* /
L_EXT_COMMENT : /(
   <C_SLASH> <C_STAR>
   (:
      (?> [^ <C_SLASH> <C_STAR> ]+ ) |  # Most stuff (no backtracking...)
      <C_SLASH> [^ <C_STAR> ]+       |  # Slash without a star
      <C_STAR> [^ <C_SLASH> ]+       |  # Star without a slash
      (?1)                              # Nesting comments
   )*
   <C_STAR> <C_SLASH> 
)/
ws          : / (: <L_SPACE>+ | <L_COMMENT> | <L_EXT_COMMENT> | <EOS> ) /

### NOTE ###
### SQL and Unicode have a bit of a shakey co-existence.  SQL was designed
### with English phrases in mind, along with English digits and identifiers.
### Thus, Unicode isn't allowed everywhere, so that proper detection between
### ASCII and Unicode can be achieved.

### However, Perl can already properly detect Unicode naturally.  So, instead
### of allowing strictest ANSI/ISO SQL in this case, we'll allow identifiers
### to be in UTF-8 without the need for the U& notation.

L_IDENT_FIRST : / [ \p{Alphabetic} \x80-\xFF <C_UNDER> ] /
L_IDENT_REST  : / [ \p{Alnum}      \x80-\xFF <C_UNDER> <C_DOLLAR> ] /
L_IDENTIFIER  : / <L_IDENT_FIRST> <L_IDENT_REST>* /

#* We use exclusive states for quoted strings, extended comments,
#* and to eliminate parsing troubles for numeric strings.
#* Exclusive states:
#*  <xb> bit string literal
#*  <xc> extended C-style comments
#*  <xd> delimited identifiers (double-quoted identifiers)
#*  <xh> hexadecimal numeric string
#*  <xq> standard quoted strings
#*  <xe> extended quoted strings (support backslash escape sequences)
#*  <xdolq> $foo$ quoted strings
#*  <xui> quoted identifier with Unicode escapes
#*  <xus> quoted string with Unicode escapes
#*  <xeu> Unicode surrogate pair in extended quoted string

### Okay, screw all of this flex hackery.
### This... is... PERL!  *kicks flex down the well*

### Here's how it's going to work: I declare a RE that grabs everything,
### and it f'ing works!  Fin.

### FIXME: Include various <EOS> checks to produce errors on unterminated strings.

#* SQL requires at least one newline in the whitespace separating
#* string literals that are to be concatenated.  Silly, but who are we
#* to argue?  Note that {whitespace_with_newline} should not have * after
#* it, whereas {whitespace} should generally have a * after it...

L_WHITESPACE_WITH_NEWLINE : / <L_HORIZ_WHITESPACE>* <L_NEWLINE> <L_SPECIAL_WHITESPACE>* /
L_HORIZ_WHITESPACE        : / (: <L_HORIZ_SPACE> | <L_COMMENT> ) /
L_SPECIAL_WHITESPACE      : / (: <L_SPACE>+ | <L_COMMENT> <L_NEWLINE> ) /

L_QUOTECONTINUE : / <C_SINGLE> <L_WHITESPACE_WITH_NEWLINE> <C_SINGLE> /

L_XBFULL : / [bB] <C_SINGLE> ( [01]* )          <C_SINGLE> /
L_XHFULL : / [xX] <C_SINGLE> ( <C_XDIGIT>* )    <C_SINGLE> /
L_XNFULL : / [nN] / =L_XQFULL  # treat like a NCHAR keyword and not a full string
L_XQFULL : /
   <C_SINGLE> 
   ( (:
      (> [^ <C_SINGLE> ]+ ) |  # Most stuff (no backtracking...)
      <C_SINGLE><C_SINGLE>  |  # Double single-quotes
      <L_QUOTECONTINUE>        # SQL-style concat (see above)
   )* )
   <C_SINGLE>
/
L_XEFULL : /
   [eE] <C_SINGLE> 
   ( (:
      (> [^ <C_BACK> <C_SINGLE> ]+ ) |  # Most stuff (no backtracking...)
      <C_BACK>   <C_SINGLE>          |  # Escaped quotes (which are technically "insecure", but we'll take them anyway)
      <C_SINGLE> <C_SINGLE>          |  # Double single-quotes
      <C_BACK> [^ <C_SINGLE> ]+      |  # Any other escaped character
      <L_QUOTECONTINUE>                 # SQL-style concat (see above)
   )* )
   <C_SINGLE>
/
### Ha!  Perl REs can even process this one all in one bite, thanks to backreferences...
L_XDOLQFULL : /
   <C_DOLLAR> ( <L_IDENTIFIER>? ) <C_DOLLAR>
   ( [^ <C_DOLLAR> ]* )
   <C_DOLLAR> \g1 <C_DOLLAR>
/
L_XDFULL : /
   <C_DOUBLE> ( [^ <C_DOUBLE> ]+ ) <C_DOUBLE>
/

### Unicode escapes ###
L_UESCAPE : / (i: UESCAPE ~ <C_SINGLE> ( [^<C_SINGLE>] ) <C_SINGLE> ) /
L_XUIFULL : / [uU] <C_AMP> <L_XDFULL> ~ <L_UESCAPE> /
L_XUSFULL : / [uU] <C_AMP> <L_XQFULL> ~ <L_UESCAPE> /

#* "self" is the set of chars that should be returned as single-character
#* tokens.  "op_chars" is the set of chars that can make up "Op" tokens,
#* which can be one or more characters long (but if a single-char token
#* appears in the "self" set, it is not to be returned as an Op).  Note
#* that the sets overlap, but each has some chars that are not in the other.
#*
#* If you change either set, adjust the character lists appearing in the
#* rule for "operator"!

L_OP_CHARS     : / [
   <C_TILDE>  <C_BANG>   <C_AT>
   <C_HASH>   <C_CARET>  <C_AMP>
   <C_PIPE>   <C_GRAVE>  <C_QMARK>
   <C_PLUS>   <C_MINUS>  <C_STAR>
   <C_LANGLE> <C_RANGLE> <C_EQUAL>
   <C_SLASH>  <C_PERCENT>
] /
L_TYPECAST     : / <C_COLON> <C_COLON> /
L_DOT_DOT      : / <C_DOT>   <C_DOT>   /
L_COLON_EQUALS : / <C_COLON> <C_EQUAL> /

L_SELF : / [
   <C_COMMA> <C_SEMI>  <C_COLON> <C_DOT> 
   <C_PLUS>  <C_MINUS> <C_SLASH> <C_STAR>
   <C_CARET> <C_EQUAL> <C_PERCENT>
   <C_LPAREN>  <C_RPAREN>
   <C_LSQUARE> <C_RSQUARE>
   <C_LANGLE>  <C_RANGLE>
] /
L_NON_MATH : / [
   <C_TILDE>  <C_BANG>   <C_AT>
   <C_HASH>   <C_CARET>  <C_AMP>
   <C_PIPE>   <C_GRAVE>  <C_QMARK>
] /

#* we no longer allow unary minus in numbers.
#* instead we pass it separately to parser. there it gets
#* coerced via doNegate() -- Leon aug 20 1999

### We aren't allowing non-English here, else all coder's brains would spontaneously explode
### at the prospect of making a Tibetian digit work with functions like int()...
#L_DIGIT  # Atom already defined
L_INTEGER : / <C_DIGIT>+ /
L_DECIMAL : / (: <C_DIGIT>* <C_DOT> <C_DIGIT>+ | <C_DIGIT>+ <C_DOT> <C_DIGIT>* (! <C_DOT> ) ) /  
L_REAL    : / (: <L_INTEGER> | <L_DECIMAL> ) [Ee] [-+]? <C_DIGIT>+ /
L_PARAM   : / ( <C_DOLLAR> <L_INTEGER> ) /

#* %%

###########################
### Lexer token returns ###
###########################

# At this point in the lexer, we have the tokens that the parser would process.
# Obviously, a parser would expect its separation to processed like whitespace.
# However, unlike a standard lexer/parser pair, a Pegex rule like "CREATE TABLE"
# implies no whitespace in-between the keywords.  Thus, we add ~ checks to
# each of the "parser tokens".

### Constants ###

BCONST : L_XBFULL ~
XCONST : L_XHFULL ~
SCONST : ( L_XQFULL | L_XEFULL | L_XUSFULL | L_XDOLQFULL ) ~
ICONST : / (<L_INTEGER>) / ~
FCONST : / (<L_REAL>|<L_DECIMAL>) / ~
PARAM  : L_PARAM ~

### Operators ###

#* Check for embedded slash-star or dash-dash; those
#* are comment starts, so operator must stop there.
#* Note that slash-star or dash-dash at the first
#* character will match a prior rule, not this one.
L_Op : / (
   <L_OP_CHARS>+? (?= <C_DASH><C_DASH> | <C_SLASH><C_STAR> ) |
   <L_OP_CHARS>{2,} |
   <L_NON_MATH>
) /

#Op: ---code rule---

TYPECAST     : L_TYPECAST ~
DOT_DOT      : L_DOT_DOT ~
COLON_EQUALS : L_COLON_EQUALS ~

### Self (single-character) tokens ###

# These are normally defined as 'X' in a traditional parser, but no such syntax
# exists in Pegex.  We can't just use atoms or /X/ syntax, because we have to 
# include token separation.  Thus, all of the tokens are defined here as P_*
# tokens, and use a naming scheme that matches the Pegex atoms.

# NOTE: We have to double-check that it doesn't end up as an Op before the
# assignment.  Self does take priority, but the Op rule will already invalidate
# itself if it realizes that it's going to be a single-character L_SELF.

P_COMMA   : !Op C_COMMA   ~;  P_SEMI    : !Op C_SEMI    ~;  P_COLON   : !Op C_COLON   ~;  P_DOT  : !Op C_DOT  ~;
P_PLUS    : !Op C_PLUS    ~;  P_MINUS   : !Op C_MINUS   ~;  P_SLASH   : !Op C_SLASH   ~;  P_STAR : !Op C_STAR ~;
P_CARET   : !Op C_CARET   ~;  P_EQUAL   : !Op C_EQUAL   ~;  P_PERCENT : !Op C_PERCENT ~;  
P_LPAREN  : !Op C_LPAREN  ~;  P_RPAREN  : !Op C_RPAREN  ~;
P_LSQUARE : !Op C_LSQUARE ~;  P_RSQUARE : !Op C_RSQUARE ~;
P_LANGLE  : !Op C_LANGLE  ~;  P_RANGLE  : !Op C_RANGLE  ~;

### Keywords ###

IDENT : ( L_XDFULL | L_XUIFULL | ( !L_KEYWORD L_IDENTIFIER ) ) ~

L_KEYWORD : / (i: 
   ABORT|ABSOLUTE|ACCESS|ACTION|ADD|ADMIN|AFTER|AGGREGATE|ALL|ALSO|ALTER|ALWAYS|ANALYSE|ANALYZE|AND|ANY|ARRAY|AS|ASC|ASSERTION|ASSIGNMENT|ASYMMETRIC|AT|ATTRIBUTE|AUTHORIZATION|
   BACKWARD|BEFORE|BEGIN|BETWEEN|BIGINT|BINARY|BIT|BOOLEAN|BOTH|BY|
   CACHE|CALLED|CASCADE|CASCADED|CASE|CAST|CATALOG|CHAIN|CHAR|CHARACTER|CHARACTERISTICS|CHECK|CHECKPOINT|CLASS|CLOSE|CLUSTER|COALESCE|COLLATE|COLLATION|COLUMN|COMMENT|COMMENTS|COMMIT|COMMITTED|CONCURRENTLY|CONFIGURATION|CONNECTION|CONSTRAINT|CONSTRAINTS|CONTENT|CONTINUE|CONVERSION|COPY|COST|CREATE|CROSS|CSV|CURRENT|CURRENT_CATALOG|CURRENT_DATE|CURRENT_ROLE|CURRENT_SCHEMA|CURRENT_TIME|CURRENT_TIMESTAMP|CURRENT_USER|CURSOR|CYCLE|
   DATA|DATABASE|DAY|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFAULTS|DEFERRABLE|DEFERRED|DEFINER|DELETE|DELIMITER|DELIMITERS|DESC|DICTIONARY|DISABLE|DISCARD|DISTINCT|DO|DOCUMENT|DOMAIN|DOUBLE|DROP|
   EACH|ELSE|ENABLE|ENCODING|ENCRYPTED|END|ENUM|ESCAPE|EVENT|EXCEPT|EXCLUDE|EXCLUDING|EXCLUSIVE|EXECUTE|EXISTS|EXPLAIN|EXTENSION|EXTERNAL|EXTRACT|
   FALSE|FAMILY|FETCH|FIRST|FLOAT|FOLLOWING|FOR|FORCE|FOREIGN|FORWARD|FREEZE|FROM|FULL|FUNCTION|FUNCTIONS|
   GLOBAL|GRANT|GRANTED|GREATEST|GROUP|
   HANDLER|HAVING|HEADER|HOLD|HOUR|
   IDENTITY|IF|ILIKE|IMMEDIATE|IMMUTABLE|IMPLICIT|IN|INCLUDING|INCREMENT|INDEX|INDEXES|INHERIT|INHERITS|INITIALLY|INLINE|INNER|INOUT|INPUT|INSENSITIVE|INSERT|INSTEAD|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|IS|ISNULL|ISOLATION|
   JOIN|
   KEY|
   LABEL|LANGUAGE|LARGE|LAST|LATERAL|LC_COLLATE|LC_CTYPE|LEADING|LEAKPROOF|LEAST|LEFT|LEVEL|LIKE|LIMIT|LISTEN|LOAD|LOCAL|LOCALTIME|LOCALTIMESTAMP|LOCATION|LOCK|
   MAPPING|MATCH|MAXVALUE|MINUTE|MINVALUE|MODE|MONTH|MOVE|
   NAME|NAMES|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONE|NOT|NOTHING|NOTIFY|NOTNULL|NOWAIT|NULL|NULLIF|NULLS|NUMERIC|
   OBJECT|OF|OFF|OFFSET|OIDS|ON|ONLY|OPERATOR|OPTION|OPTIONS|OR|ORDER|OUT|OUTER|OVER|OVERLAPS|OVERLAY|OWNED|OWNER|
   PARSER|PARTIAL|PARTITION|PASSING|PASSWORD|PLACING|PLANS|POSITION|PRECEDING|PRECISION|PREPARE|PREPARED|PRESERVE|PRIMARY|PRIOR|PRIVILEGES|PROCEDURAL|PROCEDURE|
   QUOTE|
   RANGE|READ|REAL|REASSIGN|RECHECK|RECURSIVE|REF|REFERENCES|REINDEX|RELATIVE|RELEASE|RENAME|REPEATABLE|REPLACE|REPLICA|RESET|RESTART|RESTRICT|RETURNING|RETURNS|REVOKE|RIGHT|ROLE|ROLLBACK|ROW|ROWS|RULE|
   SAVEPOINT|SCHEMA|SCROLL|SEARCH|SECOND|SECURITY|SELECT|SEQUENCE|SEQUENCES|SERIALIZABLE|SERVER|SESSION|SESSION_USER|SET|SETOF|SHARE|SHOW|SIMILAR|SIMPLE|SMALLINT|SNAPSHOT|SOME|STABLE|STANDALONE|START|STATEMENT|STATISTICS|STDIN|STDOUT|STORAGE|STRICT|STRIP|SUBSTRING|SYMMETRIC|SYSID|SYSTEM|
   TABLE|TABLES|TABLESPACE|TEMP|TEMPLATE|TEMPORARY|TEXT|THEN|TIME|TIMESTAMP|TO|TRAILING|TRANSACTION|TREAT|TRIGGER|TRIM|TRUE|TRUNCATE|TRUSTED|TYPE|TYPES|
   UNBOUNDED|UNCOMMITTED|UNENCRYPTED|UNION|UNIQUE|UNKNOWN|UNLISTEN|UNLOGGED|UNTIL|UPDATE|USER|USING|
   VACUUM|VALID|VALIDATE|VALIDATOR|VALUE|VALUES|VARCHAR|VARIADIC|VARYING|VERBOSE|VERSION|VIEW|VOLATILE|
   WHEN|WHERE|WHITESPACE|WINDOW|WITH|WITHOUT|WORK|WRAPPER|WRITE|
   XML|XMLATTRIBUTES|XMLCONCAT|XMLELEMENT|XMLEXISTS|XMLFOREST|XMLPARSE|XMLPI|XMLROOT|XMLSERIALIZE|
   YEAR|YES|
   ZONE
) (! <L_IDENT_REST>) /

ABORT             : / (i: ABORT             ) (! <L_IDENT_REST>) ~ /
ABSOLUTE          : / (i: ABSOLUTE          ) (! <L_IDENT_REST>) ~ /
ACCESS            : / (i: ACCESS            ) (! <L_IDENT_REST>) ~ /
ACTION            : / (i: ACTION            ) (! <L_IDENT_REST>) ~ /
ADD               : / (i: ADD               ) (! <L_IDENT_REST>) ~ /
ADMIN             : / (i: ADMIN             ) (! <L_IDENT_REST>) ~ /
AFTER             : / (i: AFTER             ) (! <L_IDENT_REST>) ~ /
AGGREGATE         : / (i: AGGREGATE         ) (! <L_IDENT_REST>) ~ /
ALL               : / (i: ALL               ) (! <L_IDENT_REST>) ~ /
ALSO              : / (i: ALSO              ) (! <L_IDENT_REST>) ~ /
ALTER             : / (i: ALTER             ) (! <L_IDENT_REST>) ~ /
ALWAYS            : / (i: ALWAYS            ) (! <L_IDENT_REST>) ~ /
ANALYZE           : / (i: ANALYZE|ANALYSE   ) (! <L_IDENT_REST>) ~ /  # just combine these for the "tokens"
AND               : / (i: AND               ) (! <L_IDENT_REST>) ~ /
ANY               : / (i: ANY               ) (! <L_IDENT_REST>) ~ /
ARRAY             : / (i: ARRAY             ) (! <L_IDENT_REST>) ~ /
AS                : / (i: AS                ) (! <L_IDENT_REST>) ~ /
ASC               : / (i: ASC               ) (! <L_IDENT_REST>) ~ /
ASSERTION         : / (i: ASSERTION         ) (! <L_IDENT_REST>) ~ /
ASSIGNMENT        : / (i: ASSIGNMENT        ) (! <L_IDENT_REST>) ~ /
ASYMMETRIC        : / (i: ASYMMETRIC        ) (! <L_IDENT_REST>) ~ /
AT                : / (i: AT                ) (! <L_IDENT_REST>) ~ /
ATTRIBUTE         : / (i: ATTRIBUTE         ) (! <L_IDENT_REST>) ~ /
AUTHORIZATION     : / (i: AUTHORIZATION     ) (! <L_IDENT_REST>) ~ /

BACKWARD          : / (i: BACKWARD          ) (! <L_IDENT_REST>) ~ /
BEFORE            : / (i: BEFORE            ) (! <L_IDENT_REST>) ~ /
BEGIN             : / (i: BEGIN             ) (! <L_IDENT_REST>) ~ /
BETWEEN           : / (i: BETWEEN           ) (! <L_IDENT_REST>) ~ /
BIGINT            : / (i: BIGINT            ) (! <L_IDENT_REST>) ~ /
BINARY            : / (i: BINARY            ) (! <L_IDENT_REST>) ~ /
BIT               : / (i: BIT               ) (! <L_IDENT_REST>) ~ /
BOOLEAN           : / (i: BOOLEAN           ) (! <L_IDENT_REST>) ~ /
BOTH              : / (i: BOTH              ) (! <L_IDENT_REST>) ~ /
BY                : / (i: BY                ) (! <L_IDENT_REST>) ~ /

CACHE             : / (i: CACHE             ) (! <L_IDENT_REST>) ~ /
CALLED            : / (i: CALLED            ) (! <L_IDENT_REST>) ~ /
CASCADE           : / (i: CASCADE           ) (! <L_IDENT_REST>) ~ /
CASCADED          : / (i: CASCADED          ) (! <L_IDENT_REST>) ~ /
CASE              : / (i: CASE              ) (! <L_IDENT_REST>) ~ /
CAST              : / (i: CAST              ) (! <L_IDENT_REST>) ~ /
CATALOG           : / (i: CATALOG           ) (! <L_IDENT_REST>) ~ /
CHAIN             : / (i: CHAIN             ) (! <L_IDENT_REST>) ~ /
CHAR              : / (i: CHAR              ) (! <L_IDENT_REST>) ~ /
CHARACTER         : / (i: CHARACTER         ) (! <L_IDENT_REST>) ~ /
CHARACTERISTICS   : / (i: CHARACTERISTICS   ) (! <L_IDENT_REST>) ~ /
CHECK             : / (i: CHECK             ) (! <L_IDENT_REST>) ~ /
CHECKPOINT        : / (i: CHECKPOINT        ) (! <L_IDENT_REST>) ~ /
CLASS             : / (i: CLASS             ) (! <L_IDENT_REST>) ~ /
CLOSE             : / (i: CLOSE             ) (! <L_IDENT_REST>) ~ /
CLUSTER           : / (i: CLUSTER           ) (! <L_IDENT_REST>) ~ /
COALESCE          : / (i: COALESCE          ) (! <L_IDENT_REST>) ~ /
COLLATE           : / (i: COLLATE           ) (! <L_IDENT_REST>) ~ /
COLLATION         : / (i: COLLATION         ) (! <L_IDENT_REST>) ~ /
COLUMN            : / (i: COLUMN            ) (! <L_IDENT_REST>) ~ /
COMMENT           : / (i: COMMENT           ) (! <L_IDENT_REST>) ~ /
COMMENTS          : / (i: COMMENTS          ) (! <L_IDENT_REST>) ~ /
COMMIT            : / (i: COMMIT            ) (! <L_IDENT_REST>) ~ /
COMMITTED         : / (i: COMMITTED         ) (! <L_IDENT_REST>) ~ /
CONCURRENTLY      : / (i: CONCURRENTLY      ) (! <L_IDENT_REST>) ~ /
CONFIGURATION     : / (i: CONFIGURATION     ) (! <L_IDENT_REST>) ~ /
CONNECTION        : / (i: CONNECTION        ) (! <L_IDENT_REST>) ~ /
CONSTRAINT        : / (i: CONSTRAINT        ) (! <L_IDENT_REST>) ~ /
CONSTRAINTS       : / (i: CONSTRAINTS       ) (! <L_IDENT_REST>) ~ /
CONTENT           : / (i: CONTENT           ) (! <L_IDENT_REST>) ~ /
CONTINUE          : / (i: CONTINUE          ) (! <L_IDENT_REST>) ~ /
CONVERSION        : / (i: CONVERSION        ) (! <L_IDENT_REST>) ~ /
COPY              : / (i: COPY              ) (! <L_IDENT_REST>) ~ /
COST              : / (i: COST              ) (! <L_IDENT_REST>) ~ /
CREATE            : / (i: CREATE            ) (! <L_IDENT_REST>) ~ /
CROSS             : / (i: CROSS             ) (! <L_IDENT_REST>) ~ /
CSV               : / (i: CSV               ) (! <L_IDENT_REST>) ~ /
CURRENT           : / (i: CURRENT           ) (! <L_IDENT_REST>) ~ /
CURRENT_CATALOG   : / (i: CURRENT_CATALOG   ) (! <L_IDENT_REST>) ~ /
CURRENT_DATE      : / (i: CURRENT_DATE      ) (! <L_IDENT_REST>) ~ /
CURRENT_ROLE      : / (i: CURRENT_ROLE      ) (! <L_IDENT_REST>) ~ /
CURRENT_SCHEMA    : / (i: CURRENT_SCHEMA    ) (! <L_IDENT_REST>) ~ /
CURRENT_TIME      : / (i: CURRENT_TIME      ) (! <L_IDENT_REST>) ~ /
CURRENT_TIMESTAMP : / (i: CURRENT_TIMESTAMP ) (! <L_IDENT_REST>) ~ /
CURRENT_USER      : / (i: CURRENT_USER      ) (! <L_IDENT_REST>) ~ /
CURSOR            : / (i: CURSOR            ) (! <L_IDENT_REST>) ~ /
CYCLE             : / (i: CYCLE             ) (! <L_IDENT_REST>) ~ /

DATA              : / (i: DATA              ) (! <L_IDENT_REST>) ~ /
DATABASE          : / (i: DATABASE          ) (! <L_IDENT_REST>) ~ /
DAY               : / (i: DAY               ) (! <L_IDENT_REST>) ~ /
DEALLOCATE        : / (i: DEALLOCATE        ) (! <L_IDENT_REST>) ~ /
DEC               : / (i: DEC               ) (! <L_IDENT_REST>) ~ /
DECIMAL           : / (i: DECIMAL           ) (! <L_IDENT_REST>) ~ /
DECLARE           : / (i: DECLARE           ) (! <L_IDENT_REST>) ~ /
DEFAULT           : / (i: DEFAULT           ) (! <L_IDENT_REST>) ~ /
DEFAULTS          : / (i: DEFAULTS          ) (! <L_IDENT_REST>) ~ /
DEFERRABLE        : / (i: DEFERRABLE        ) (! <L_IDENT_REST>) ~ /
DEFERRED          : / (i: DEFERRED          ) (! <L_IDENT_REST>) ~ /
DEFINER           : / (i: DEFINER           ) (! <L_IDENT_REST>) ~ /
DELETE            : / (i: DELETE            ) (! <L_IDENT_REST>) ~ /
DELIMITER         : / (i: DELIMITER         ) (! <L_IDENT_REST>) ~ /
DELIMITERS        : / (i: DELIMITERS        ) (! <L_IDENT_REST>) ~ /
DESC              : / (i: DESC              ) (! <L_IDENT_REST>) ~ /
DICTIONARY        : / (i: DICTIONARY        ) (! <L_IDENT_REST>) ~ /
DISABLE           : / (i: DISABLE           ) (! <L_IDENT_REST>) ~ /
DISCARD           : / (i: DISCARD           ) (! <L_IDENT_REST>) ~ /
DISTINCT          : / (i: DISTINCT          ) (! <L_IDENT_REST>) ~ /
DO                : / (i: DO                ) (! <L_IDENT_REST>) ~ /
DOCUMENT          : / (i: DOCUMENT          ) (! <L_IDENT_REST>) ~ /
DOMAIN            : / (i: DOMAIN            ) (! <L_IDENT_REST>) ~ /
DOUBLE            : / (i: DOUBLE            ) (! <L_IDENT_REST>) ~ /
DROP              : / (i: DROP              ) (! <L_IDENT_REST>) ~ /

EACH              : / (i: EACH              ) (! <L_IDENT_REST>) ~ /
ELSE              : / (i: ELSE              ) (! <L_IDENT_REST>) ~ /
ENABLE            : / (i: ENABLE            ) (! <L_IDENT_REST>) ~ /
ENCODING          : / (i: ENCODING          ) (! <L_IDENT_REST>) ~ /
ENCRYPTED         : / (i: ENCRYPTED         ) (! <L_IDENT_REST>) ~ /
END               : / (i: END               ) (! <L_IDENT_REST>) ~ /
ENUM              : / (i: ENUM              ) (! <L_IDENT_REST>) ~ /
ESCAPE            : / (i: ESCAPE            ) (! <L_IDENT_REST>) ~ /
EVENT             : / (i: EVENT             ) (! <L_IDENT_REST>) ~ /
EXCEPT            : / (i: EXCEPT            ) (! <L_IDENT_REST>) ~ /
EXCLUDE           : / (i: EXCLUDE           ) (! <L_IDENT_REST>) ~ /
EXCLUDING         : / (i: EXCLUDING         ) (! <L_IDENT_REST>) ~ /
EXCLUSIVE         : / (i: EXCLUSIVE         ) (! <L_IDENT_REST>) ~ /
EXECUTE           : / (i: EXECUTE           ) (! <L_IDENT_REST>) ~ /
EXISTS            : / (i: EXISTS            ) (! <L_IDENT_REST>) ~ /
EXPLAIN           : / (i: EXPLAIN           ) (! <L_IDENT_REST>) ~ /
EXTENSION         : / (i: EXTENSION         ) (! <L_IDENT_REST>) ~ /
EXTERNAL          : / (i: EXTERNAL          ) (! <L_IDENT_REST>) ~ /
EXTRACT           : / (i: EXTRACT           ) (! <L_IDENT_REST>) ~ /

FALSE             : / (i: FALSE             ) (! <L_IDENT_REST>) ~ /
FAMILY            : / (i: FAMILY            ) (! <L_IDENT_REST>) ~ /
FETCH             : / (i: FETCH             ) (! <L_IDENT_REST>) ~ /
FIRST             : / (i: FIRST             ) (! <L_IDENT_REST>) ~ /
FLOAT             : / (i: FLOAT             ) (! <L_IDENT_REST>) ~ /
FOLLOWING         : / (i: FOLLOWING         ) (! <L_IDENT_REST>) ~ /
FOR               : / (i: FOR               ) (! <L_IDENT_REST>) ~ /
FORCE             : / (i: FORCE             ) (! <L_IDENT_REST>) ~ /
FOREIGN           : / (i: FOREIGN           ) (! <L_IDENT_REST>) ~ /
FORWARD           : / (i: FORWARD           ) (! <L_IDENT_REST>) ~ /
FREEZE            : / (i: FREEZE            ) (! <L_IDENT_REST>) ~ /
FROM              : / (i: FROM              ) (! <L_IDENT_REST>) ~ /
FULL              : / (i: FULL              ) (! <L_IDENT_REST>) ~ /
FUNCTION          : / (i: FUNCTION          ) (! <L_IDENT_REST>) ~ /
FUNCTIONS         : / (i: FUNCTIONS         ) (! <L_IDENT_REST>) ~ /

GLOBAL            : / (i: GLOBAL            ) (! <L_IDENT_REST>) ~ /
GRANT             : / (i: GRANT             ) (! <L_IDENT_REST>) ~ /
GRANTED           : / (i: GRANTED           ) (! <L_IDENT_REST>) ~ /
GREATEST          : / (i: GREATEST          ) (! <L_IDENT_REST>) ~ /
GROUP             : / (i: GROUP             ) (! <L_IDENT_REST>) ~ /

HANDLER           : / (i: HANDLER           ) (! <L_IDENT_REST>) ~ /
HAVING            : / (i: HAVING            ) (! <L_IDENT_REST>) ~ /
HEADER            : / (i: HEADER            ) (! <L_IDENT_REST>) ~ /
HOLD              : / (i: HOLD              ) (! <L_IDENT_REST>) ~ /
HOUR              : / (i: HOUR              ) (! <L_IDENT_REST>) ~ /

IDENTITY          : / (i: IDENTITY          ) (! <L_IDENT_REST>) ~ /
IF                : / (i: IF                ) (! <L_IDENT_REST>) ~ /
ILIKE             : / (i: ILIKE             ) (! <L_IDENT_REST>) ~ /
IMMEDIATE         : / (i: IMMEDIATE         ) (! <L_IDENT_REST>) ~ /
IMMUTABLE         : / (i: IMMUTABLE         ) (! <L_IDENT_REST>) ~ /
IMPLICIT          : / (i: IMPLICIT          ) (! <L_IDENT_REST>) ~ /
IN                : / (i: IN                ) (! <L_IDENT_REST>) ~ /
INCLUDING         : / (i: INCLUDING         ) (! <L_IDENT_REST>) ~ /
INCREMENT         : / (i: INCREMENT         ) (! <L_IDENT_REST>) ~ /
INDEX             : / (i: INDEX             ) (! <L_IDENT_REST>) ~ /
INDEXES           : / (i: INDEXES           ) (! <L_IDENT_REST>) ~ /
INHERIT           : / (i: INHERIT           ) (! <L_IDENT_REST>) ~ /
INHERITS          : / (i: INHERITS          ) (! <L_IDENT_REST>) ~ /
INITIALLY         : / (i: INITIALLY         ) (! <L_IDENT_REST>) ~ /
INLINE            : / (i: INLINE            ) (! <L_IDENT_REST>) ~ /
INNER             : / (i: INNER             ) (! <L_IDENT_REST>) ~ /
INOUT             : / (i: INOUT             ) (! <L_IDENT_REST>) ~ /
INPUT             : / (i: INPUT             ) (! <L_IDENT_REST>) ~ /
INSENSITIVE       : / (i: INSENSITIVE       ) (! <L_IDENT_REST>) ~ /
INSERT            : / (i: INSERT            ) (! <L_IDENT_REST>) ~ /
INSTEAD           : / (i: INSTEAD           ) (! <L_IDENT_REST>) ~ /
INT               : / (i: INT               ) (! <L_IDENT_REST>) ~ /
INTEGER           : / (i: INTEGER           ) (! <L_IDENT_REST>) ~ /
INTERSECT         : / (i: INTERSECT         ) (! <L_IDENT_REST>) ~ /
INTERVAL          : / (i: INTERVAL          ) (! <L_IDENT_REST>) ~ /
INTO              : / (i: INTO              ) (! <L_IDENT_REST>) ~ /
INVOKER           : / (i: INVOKER           ) (! <L_IDENT_REST>) ~ /
IS                : / (i: IS                ) (! <L_IDENT_REST>) ~ /
ISNULL            : / (i: ISNULL            ) (! <L_IDENT_REST>) ~ /
ISOLATION         : / (i: ISOLATION         ) (! <L_IDENT_REST>) ~ /

JOIN              : / (i: JOIN              ) (! <L_IDENT_REST>) ~ /

KEY               : / (i: KEY               ) (! <L_IDENT_REST>) ~ /

LABEL             : / (i: LABEL             ) (! <L_IDENT_REST>) ~ /
LANGUAGE          : / (i: LANGUAGE          ) (! <L_IDENT_REST>) ~ /
LARGE             : / (i: LARGE             ) (! <L_IDENT_REST>) ~ /
LAST              : / (i: LAST              ) (! <L_IDENT_REST>) ~ /
LATERAL           : / (i: LATERAL           ) (! <L_IDENT_REST>) ~ /
LC_COLLATE        : / (i: LC_COLLATE        ) (! <L_IDENT_REST>) ~ /
LC_CTYPE          : / (i: LC_CTYPE          ) (! <L_IDENT_REST>) ~ /
LEADING           : / (i: LEADING           ) (! <L_IDENT_REST>) ~ /
LEAKPROOF         : / (i: LEAKPROOF         ) (! <L_IDENT_REST>) ~ /
LEAST             : / (i: LEAST             ) (! <L_IDENT_REST>) ~ /
LEFT              : / (i: LEFT              ) (! <L_IDENT_REST>) ~ /
LEVEL             : / (i: LEVEL             ) (! <L_IDENT_REST>) ~ /
LIKE              : / (i: LIKE              ) (! <L_IDENT_REST>) ~ /
LIMIT             : / (i: LIMIT             ) (! <L_IDENT_REST>) ~ /
LISTEN            : / (i: LISTEN            ) (! <L_IDENT_REST>) ~ /
LOAD              : / (i: LOAD              ) (! <L_IDENT_REST>) ~ /
LOCAL             : / (i: LOCAL             ) (! <L_IDENT_REST>) ~ /
LOCALTIME         : / (i: LOCALTIME         ) (! <L_IDENT_REST>) ~ /
LOCALTIMESTAMP    : / (i: LOCALTIMESTAMP    ) (! <L_IDENT_REST>) ~ /
LOCATION          : / (i: LOCATION          ) (! <L_IDENT_REST>) ~ /
LOCK              : / (i: LOCK              ) (! <L_IDENT_REST>) ~ /

MAPPING           : / (i: MAPPING           ) (! <L_IDENT_REST>) ~ /
MATCH             : / (i: MATCH             ) (! <L_IDENT_REST>) ~ /
MAXVALUE          : / (i: MAXVALUE          ) (! <L_IDENT_REST>) ~ /
MINUTE            : / (i: MINUTE            ) (! <L_IDENT_REST>) ~ /
MINVALUE          : / (i: MINVALUE          ) (! <L_IDENT_REST>) ~ /
MODE              : / (i: MODE              ) (! <L_IDENT_REST>) ~ /
MONTH             : / (i: MONTH             ) (! <L_IDENT_REST>) ~ /
MOVE              : / (i: MOVE              ) (! <L_IDENT_REST>) ~ /

NAME              : / (i: NAME              ) (! <L_IDENT_REST>) ~ /
NAMES             : / (i: NAMES             ) (! <L_IDENT_REST>) ~ /
NATIONAL          : / (i: NATIONAL          ) (! <L_IDENT_REST>) ~ /
NATURAL           : / (i: NATURAL           ) (! <L_IDENT_REST>) ~ /
NCHAR             : / <L_XNFULL> | (i: NCHAR) (! <L_IDENT_REST>) ~ /
NEXT              : / (i: NEXT              ) (! <L_IDENT_REST>) ~ /
NO                : / (i: NO                ) (! <L_IDENT_REST>) ~ /
NONE              : / (i: NONE              ) (! <L_IDENT_REST>) ~ /
NOT               : / (i: NOT               ) (! <L_IDENT_REST>) ~ /
NOTHING           : / (i: NOTHING           ) (! <L_IDENT_REST>) ~ /
NOTIFY            : / (i: NOTIFY            ) (! <L_IDENT_REST>) ~ /
NOTNULL           : / (i: NOTNULL           ) (! <L_IDENT_REST>) ~ /
NOWAIT            : / (i: NOWAIT            ) (! <L_IDENT_REST>) ~ /
NULL              : / (i: NULL              ) (! <L_IDENT_REST>) ~ /
NULLIF            : / (i: NULLIF            ) (! <L_IDENT_REST>) ~ /
NULLS             : / (i: NULLS             ) (! <L_IDENT_REST>) ~ /
NUMERIC           : / (i: NUMERIC           ) (! <L_IDENT_REST>) ~ /

OBJECT            : / (i: OBJECT            ) (! <L_IDENT_REST>) ~ /
OF                : / (i: OF                ) (! <L_IDENT_REST>) ~ /
OFF               : / (i: OFF               ) (! <L_IDENT_REST>) ~ /
OFFSET            : / (i: OFFSET            ) (! <L_IDENT_REST>) ~ /
OIDS              : / (i: OIDS              ) (! <L_IDENT_REST>) ~ /
ON                : / (i: ON                ) (! <L_IDENT_REST>) ~ /
ONLY              : / (i: ONLY              ) (! <L_IDENT_REST>) ~ /
OPERATOR          : / (i: OPERATOR          ) (! <L_IDENT_REST>) ~ /
OPTION            : / (i: OPTION            ) (! <L_IDENT_REST>) ~ /
OPTIONS           : / (i: OPTIONS           ) (! <L_IDENT_REST>) ~ /
OR                : / (i: OR                ) (! <L_IDENT_REST>) ~ /
ORDER             : / (i: ORDER             ) (! <L_IDENT_REST>) ~ /
OUT               : / (i: OUT               ) (! <L_IDENT_REST>) ~ /
OUTER             : / (i: OUTER             ) (! <L_IDENT_REST>) ~ /
OVER              : / (i: OVER              ) (! <L_IDENT_REST>) ~ /
OVERLAPS          : / (i: OVERLAPS          ) (! <L_IDENT_REST>) ~ /
OVERLAY           : / (i: OVERLAY           ) (! <L_IDENT_REST>) ~ /
OWNED             : / (i: OWNED             ) (! <L_IDENT_REST>) ~ /
OWNER             : / (i: OWNER             ) (! <L_IDENT_REST>) ~ /

PARSER            : / (i: PARSER            ) (! <L_IDENT_REST>) ~ /
PARTIAL           : / (i: PARTIAL           ) (! <L_IDENT_REST>) ~ /
PARTITION         : / (i: PARTITION         ) (! <L_IDENT_REST>) ~ /
PASSING           : / (i: PASSING           ) (! <L_IDENT_REST>) ~ /
PASSWORD          : / (i: PASSWORD          ) (! <L_IDENT_REST>) ~ /
PLACING           : / (i: PLACING           ) (! <L_IDENT_REST>) ~ /
PLANS             : / (i: PLANS             ) (! <L_IDENT_REST>) ~ /
POSITION          : / (i: POSITION          ) (! <L_IDENT_REST>) ~ /
PRECEDING         : / (i: PRECEDING         ) (! <L_IDENT_REST>) ~ /
PRECISION         : / (i: PRECISION         ) (! <L_IDENT_REST>) ~ /
PREPARE           : / (i: PREPARE           ) (! <L_IDENT_REST>) ~ /
PREPARED          : / (i: PREPARED          ) (! <L_IDENT_REST>) ~ /
PRESERVE          : / (i: PRESERVE          ) (! <L_IDENT_REST>) ~ /
PRIMARY           : / (i: PRIMARY           ) (! <L_IDENT_REST>) ~ /
PRIOR             : / (i: PRIOR             ) (! <L_IDENT_REST>) ~ /
PRIVILEGES        : / (i: PRIVILEGES        ) (! <L_IDENT_REST>) ~ /
PROCEDURAL        : / (i: PROCEDURAL        ) (! <L_IDENT_REST>) ~ /
PROCEDURE         : / (i: PROCEDURE         ) (! <L_IDENT_REST>) ~ /

QUOTE             : / (i: QUOTE             ) (! <L_IDENT_REST>) ~ /

RANGE             : / (i: RANGE             ) (! <L_IDENT_REST>) ~ /
READ              : / (i: READ              ) (! <L_IDENT_REST>) ~ /
REAL              : / (i: REAL              ) (! <L_IDENT_REST>) ~ /
REASSIGN          : / (i: REASSIGN          ) (! <L_IDENT_REST>) ~ /
RECHECK           : / (i: RECHECK           ) (! <L_IDENT_REST>) ~ /
RECURSIVE         : / (i: RECURSIVE         ) (! <L_IDENT_REST>) ~ /
REF               : / (i: REF               ) (! <L_IDENT_REST>) ~ /
REFERENCES        : / (i: REFERENCES        ) (! <L_IDENT_REST>) ~ /
REINDEX           : / (i: REINDEX           ) (! <L_IDENT_REST>) ~ /
RELATIVE          : / (i: RELATIVE          ) (! <L_IDENT_REST>) ~ /
RELEASE           : / (i: RELEASE           ) (! <L_IDENT_REST>) ~ /
RENAME            : / (i: RENAME            ) (! <L_IDENT_REST>) ~ /
REPEATABLE        : / (i: REPEATABLE        ) (! <L_IDENT_REST>) ~ /
REPLACE           : / (i: REPLACE           ) (! <L_IDENT_REST>) ~ /
REPLICA           : / (i: REPLICA           ) (! <L_IDENT_REST>) ~ /
RESET             : / (i: RESET             ) (! <L_IDENT_REST>) ~ /
RESTART           : / (i: RESTART           ) (! <L_IDENT_REST>) ~ /
RESTRICT          : / (i: RESTRICT          ) (! <L_IDENT_REST>) ~ /
RETURNING         : / (i: RETURNING         ) (! <L_IDENT_REST>) ~ /
RETURNS           : / (i: RETURNS           ) (! <L_IDENT_REST>) ~ /
REVOKE            : / (i: REVOKE            ) (! <L_IDENT_REST>) ~ /
RIGHT             : / (i: RIGHT             ) (! <L_IDENT_REST>) ~ /
ROLE              : / (i: ROLE              ) (! <L_IDENT_REST>) ~ /
ROLLBACK          : / (i: ROLLBACK          ) (! <L_IDENT_REST>) ~ /
ROW               : / (i: ROW               ) (! <L_IDENT_REST>) ~ /
ROWS              : / (i: ROWS              ) (! <L_IDENT_REST>) ~ /
RULE              : / (i: RULE              ) (! <L_IDENT_REST>) ~ /

SAVEPOINT         : / (i: SAVEPOINT         ) (! <L_IDENT_REST>) ~ /
SCHEMA            : / (i: SCHEMA            ) (! <L_IDENT_REST>) ~ /
SCROLL            : / (i: SCROLL            ) (! <L_IDENT_REST>) ~ /
SEARCH            : / (i: SEARCH            ) (! <L_IDENT_REST>) ~ /
SECOND            : / (i: SECOND            ) (! <L_IDENT_REST>) ~ /
SECURITY          : / (i: SECURITY          ) (! <L_IDENT_REST>) ~ /
SELECT            : / (i: SELECT            ) (! <L_IDENT_REST>) ~ /
SEQUENCE          : / (i: SEQUENCE          ) (! <L_IDENT_REST>) ~ /
SEQUENCES         : / (i: SEQUENCES         ) (! <L_IDENT_REST>) ~ /
SERIALIZABLE      : / (i: SERIALIZABLE      ) (! <L_IDENT_REST>) ~ /
SERVER            : / (i: SERVER            ) (! <L_IDENT_REST>) ~ /
SESSION           : / (i: SESSION           ) (! <L_IDENT_REST>) ~ /
SESSION_USER      : / (i: SESSION_USER      ) (! <L_IDENT_REST>) ~ /
SET               : / (i: SET               ) (! <L_IDENT_REST>) ~ /
SETOF             : / (i: SETOF             ) (! <L_IDENT_REST>) ~ /
SHARE             : / (i: SHARE             ) (! <L_IDENT_REST>) ~ /
SHOW              : / (i: SHOW              ) (! <L_IDENT_REST>) ~ /
SIMILAR           : / (i: SIMILAR           ) (! <L_IDENT_REST>) ~ /
SIMPLE            : / (i: SIMPLE            ) (! <L_IDENT_REST>) ~ /
SMALLINT          : / (i: SMALLINT          ) (! <L_IDENT_REST>) ~ /
SNAPSHOT          : / (i: SNAPSHOT          ) (! <L_IDENT_REST>) ~ /
SOME              : / (i: SOME              ) (! <L_IDENT_REST>) ~ /
STABLE            : / (i: STABLE            ) (! <L_IDENT_REST>) ~ /
STANDALONE        : / (i: STANDALONE        ) (! <L_IDENT_REST>) ~ /
START             : / (i: START             ) (! <L_IDENT_REST>) ~ /
STATEMENT         : / (i: STATEMENT         ) (! <L_IDENT_REST>) ~ /
STATISTICS        : / (i: STATISTICS        ) (! <L_IDENT_REST>) ~ /
STDIN             : / (i: STDIN             ) (! <L_IDENT_REST>) ~ /
STDOUT            : / (i: STDOUT            ) (! <L_IDENT_REST>) ~ /
STORAGE           : / (i: STORAGE           ) (! <L_IDENT_REST>) ~ /
STRICT            : / (i: STRICT            ) (! <L_IDENT_REST>) ~ /
STRIP             : / (i: STRIP             ) (! <L_IDENT_REST>) ~ /
SUBSTRING         : / (i: SUBSTRING         ) (! <L_IDENT_REST>) ~ /
SYMMETRIC         : / (i: SYMMETRIC         ) (! <L_IDENT_REST>) ~ /
SYSID             : / (i: SYSID             ) (! <L_IDENT_REST>) ~ /
SYSTEM            : / (i: SYSTEM            ) (! <L_IDENT_REST>) ~ /

TABLE             : / (i: TABLE             ) (! <L_IDENT_REST>) ~ /
TABLES            : / (i: TABLES            ) (! <L_IDENT_REST>) ~ /
TABLESPACE        : / (i: TABLESPACE        ) (! <L_IDENT_REST>) ~ /
TEMP              : / (i: TEMP              ) (! <L_IDENT_REST>) ~ /
TEMPLATE          : / (i: TEMPLATE          ) (! <L_IDENT_REST>) ~ /
TEMPORARY         : / (i: TEMPORARY         ) (! <L_IDENT_REST>) ~ /
TEXT              : / (i: TEXT              ) (! <L_IDENT_REST>) ~ /
THEN              : / (i: THEN              ) (! <L_IDENT_REST>) ~ /
TIME              : / (i: TIME              ) (! <L_IDENT_REST>) ~ /
TIMESTAMP         : / (i: TIMESTAMP         ) (! <L_IDENT_REST>) ~ /
TO                : / (i: TO                ) (! <L_IDENT_REST>) ~ /
TRAILING          : / (i: TRAILING          ) (! <L_IDENT_REST>) ~ /
TRANSACTION       : / (i: TRANSACTION       ) (! <L_IDENT_REST>) ~ /
TREAT             : / (i: TREAT             ) (! <L_IDENT_REST>) ~ /
TRIGGER           : / (i: TRIGGER           ) (! <L_IDENT_REST>) ~ /
TRIM              : / (i: TRIM              ) (! <L_IDENT_REST>) ~ /
TRUE              : / (i: TRUE              ) (! <L_IDENT_REST>) ~ /
TRUNCATE          : / (i: TRUNCATE          ) (! <L_IDENT_REST>) ~ /
TRUSTED           : / (i: TRUSTED           ) (! <L_IDENT_REST>) ~ /
TYPE              : / (i: TYPE              ) (! <L_IDENT_REST>) ~ /
TYPES             : / (i: TYPES             ) (! <L_IDENT_REST>) ~ /

UNBOUNDED         : / (i: UNBOUNDED         ) (! <L_IDENT_REST>) ~ /
UNCOMMITTED       : / (i: UNCOMMITTED       ) (! <L_IDENT_REST>) ~ /
UNENCRYPTED       : / (i: UNENCRYPTED       ) (! <L_IDENT_REST>) ~ /
UNION             : / (i: UNION             ) (! <L_IDENT_REST>) ~ /
UNIQUE            : / (i: UNIQUE            ) (! <L_IDENT_REST>) ~ /
UNKNOWN           : / (i: UNKNOWN           ) (! <L_IDENT_REST>) ~ /
UNLISTEN          : / (i: UNLISTEN          ) (! <L_IDENT_REST>) ~ /
UNLOGGED          : / (i: UNLOGGED          ) (! <L_IDENT_REST>) ~ /
UNTIL             : / (i: UNTIL             ) (! <L_IDENT_REST>) ~ /
UPDATE            : / (i: UPDATE            ) (! <L_IDENT_REST>) ~ /
USER              : / (i: USER              ) (! <L_IDENT_REST>) ~ /
USING             : / (i: USING             ) (! <L_IDENT_REST>) ~ /

VACUUM            : / (i: VACUUM            ) (! <L_IDENT_REST>) ~ /
VALID             : / (i: VALID             ) (! <L_IDENT_REST>) ~ /
VALIDATE          : / (i: VALIDATE          ) (! <L_IDENT_REST>) ~ /
VALIDATOR         : / (i: VALIDATOR         ) (! <L_IDENT_REST>) ~ /
VALUE             : / (i: VALUE             ) (! <L_IDENT_REST>) ~ /
VALUES            : / (i: VALUES            ) (! <L_IDENT_REST>) ~ /
VARCHAR           : / (i: VARCHAR           ) (! <L_IDENT_REST>) ~ /
VARIADIC          : / (i: VARIADIC          ) (! <L_IDENT_REST>) ~ /
VARYING           : / (i: VARYING           ) (! <L_IDENT_REST>) ~ /
VERBOSE           : / (i: VERBOSE           ) (! <L_IDENT_REST>) ~ /
VERSION           : / (i: VERSION           ) (! <L_IDENT_REST>) ~ /
VIEW              : / (i: VIEW              ) (! <L_IDENT_REST>) ~ /
VOLATILE          : / (i: VOLATILE          ) (! <L_IDENT_REST>) ~ /

WHEN              : / (i: WHEN              ) (! <L_IDENT_REST>) ~ /
WHERE             : / (i: WHERE             ) (! <L_IDENT_REST>) ~ /
WHITESPACE        : / (i: WHITESPACE        ) (! <L_IDENT_REST>) ~ /
WINDOW            : / (i: WINDOW            ) (! <L_IDENT_REST>) ~ /
WITH              : / (i: WITH              ) (! <L_IDENT_REST>) ~ /
WITHOUT           : / (i: WITHOUT           ) (! <L_IDENT_REST>) ~ /
WORK              : / (i: WORK              ) (! <L_IDENT_REST>) ~ /
WRAPPER           : / (i: WRAPPER           ) (! <L_IDENT_REST>) ~ /
WRITE             : / (i: WRITE             ) (! <L_IDENT_REST>) ~ /

XML               : / (i: XML               ) (! <L_IDENT_REST>) ~ /
XMLATTRIBUTES     : / (i: XMLATTRIBUTES     ) (! <L_IDENT_REST>) ~ /
XMLCONCAT         : / (i: XMLCONCAT         ) (! <L_IDENT_REST>) ~ /
XMLELEMENT        : / (i: XMLELEMENT        ) (! <L_IDENT_REST>) ~ /
XMLEXISTS         : / (i: XMLEXISTS         ) (! <L_IDENT_REST>) ~ /
XMLFOREST         : / (i: XMLFOREST         ) (! <L_IDENT_REST>) ~ /
XMLPARSE          : / (i: XMLPARSE          ) (! <L_IDENT_REST>) ~ /
XMLPI             : / (i: XMLPI             ) (! <L_IDENT_REST>) ~ /
XMLROOT           : / (i: XMLROOT           ) (! <L_IDENT_REST>) ~ /
XMLSERIALIZE      : / (i: XMLSERIALIZE      ) (! <L_IDENT_REST>) ~ /

YEAR              : / (i: YEAR              ) (! <L_IDENT_REST>) ~ /
YES               : / (i: YES               ) (! <L_IDENT_REST>) ~ /

ZONE              : / (i: ZONE              ) (! <L_IDENT_REST>) ~ /