Edit on GitHub

sqlglot.dialects.oracle

  1from __future__ import annotations
  2
  3import string
  4import typing as t
  5
  6from sqlglot import exp, tokens
  7from sqlglot.dialects.dialect import (
  8    Dialect,
  9    NormalizationStrategy,
 10)
 11from sqlglot.generators.oracle import OracleGenerator
 12from sqlglot.parsers.oracle import OracleParser
 13from sqlglot.tokens import TokenType
 14
 15
 16class Oracle(Dialect):
 17    ALIAS_POST_TABLESAMPLE = True
 18    LOCKING_READS_SUPPORTED = True
 19    TABLESAMPLE_SIZE_IS_PERCENT = True
 20    NULL_ORDERING = "nulls_are_large"
 21    ON_CONDITION_EMPTY_BEFORE_ERROR = False
 22    ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = False
 23    DISABLES_ALIAS_REF_EXPANSION = True
 24    INTERSECT_BINDS_TIGHTER_THAN_UNION_AND_EXCEPT = False
 25
 26    # See section 8: https://docs.oracle.com/cd/A97630_01/server.920/a96540/sql_elements9a.htm
 27    NORMALIZATION_STRATEGY = NormalizationStrategy.UPPERCASE
 28
 29    # https://docs.oracle.com/database/121/SQLRF/sql_elements004.htm#SQLRF00212
 30    # https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes
 31    TIME_MAPPING = {
 32        "D": "%u",  # Day of week (1-7)
 33        "DAY": "%A",  # name of day
 34        "DD": "%d",  # day of month (1-31)
 35        "DDD": "%j",  # day of year (1-366)
 36        "DY": "%a",  # abbreviated name of day
 37        "HH": "%I",  # Hour of day (1-12)
 38        "HH12": "%I",  # alias for HH
 39        "HH24": "%H",  # Hour of day (0-23)
 40        "IW": "%V",  # Calendar week of year (1-52 or 1-53), as defined by the ISO 8601 standard
 41        "IYYY": "%G",  # 4-digit year of the ISO 8601 week-numbering calendar
 42        "MI": "%M",  # Minute (0-59)
 43        "MM": "%m",  # Month (01-12; January = 01)
 44        "MON": "%b",  # Abbreviated name of month
 45        "MONTH": "%B",  # Name of month
 46        "SS": "%S",  # Second (0-59)
 47        "WW": "%W",  # Week of year (1-53)
 48        "YY": "%y",  # 15
 49        "YYYY": "%Y",  # 2015
 50        "FF6": "%f",  # only 6 digits are supported in python formats
 51    }
 52
 53    PSEUDOCOLUMNS = {"ROWNUM", "ROWID", "OBJECT_ID", "OBJECT_VALUE", "LEVEL"}
 54
 55    def can_quote(self, identifier: exp.Identifier, identify: str | bool = "safe") -> bool:
 56        # Disable quoting for pseudocolumns as it may break queries e.g
 57        # `WHERE "ROWNUM" = ...` does not work but `WHERE ROWNUM = ...` does
 58        return (
 59            identifier.quoted or not isinstance(identifier.parent, exp.Pseudocolumn)
 60        ) and super().can_quote(identifier, identify=identify)
 61
 62    class Tokenizer(tokens.Tokenizer):
 63        VAR_SINGLE_TOKENS = {"@", "$", "#"}
 64
 65        UNICODE_STRINGS = [
 66            (prefix + q, q)
 67            for q in t.cast(list[str], tokens.Tokenizer.QUOTES)
 68            for prefix in ("U", "u")
 69        ]
 70
 71        # https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Literals.html
 72        # Alternative quoting, e.g. q'[it's]': the delimiters are part of the quote, so the
 73        # text in between is taken as is, without escapes
 74        RAW_STRINGS = [
 75            (f"{prefix}'{start}", f"{end}'")
 76            for prefix in ("q", "Q")
 77            for start, end in (
 78                ("[", "]"),
 79                ("{", "}"),
 80                ("(", ")"),
 81                ("<", ">"),
 82                *(
 83                    (c, c)
 84                    for c in string.ascii_letters + string.digits + string.punctuation
 85                    if c not in "[{(<"
 86                ),
 87            )
 88        ]
 89        NATIONAL_RAW_STRINGS = [
 90            (prefix + start, end)
 91            for start, end in t.cast(list[tuple[str, str]], RAW_STRINGS)
 92            for prefix in ("n", "N")
 93        ]
 94        STRING_ESCAPES_ALLOWED_IN_RAW_STRINGS = False
 95
 96        NESTED_COMMENTS = False
 97
 98        KEYWORDS = {
 99            **tokens.Tokenizer.KEYWORDS,
100            "(+)": TokenType.JOIN_MARKER,
101            # https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Comparison-Conditions.html
102            "^=": TokenType.NEQ,
103            "BINARY_DOUBLE": TokenType.DOUBLE,
104            "BINARY_FLOAT": TokenType.FLOAT,
105            "BULK COLLECT INTO": TokenType.BULK_COLLECT_INTO,
106            "COLUMNS": TokenType.COLUMN,
107            "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
108            "MINUS": TokenType.EXCEPT,
109            "NVARCHAR2": TokenType.NVARCHAR,
110            "ORDER SIBLINGS BY": TokenType.ORDER_SIBLINGS_BY,
111            "SAMPLE": TokenType.TABLE_SAMPLE,
112            "START": TokenType.BEGIN,
113            "SUBPARTITION": TokenType.PARTITION,
114            "TOP": TokenType.TOP,
115            "VARCHAR2": TokenType.VARCHAR,
116            "SYSTIMESTAMP": TokenType.SYSTIMESTAMP,
117        }
118
119    Parser = OracleParser
120
121    Generator = OracleGenerator
class Oracle(sqlglot.dialects.dialect.Dialect):
 17class Oracle(Dialect):
 18    ALIAS_POST_TABLESAMPLE = True
 19    LOCKING_READS_SUPPORTED = True
 20    TABLESAMPLE_SIZE_IS_PERCENT = True
 21    NULL_ORDERING = "nulls_are_large"
 22    ON_CONDITION_EMPTY_BEFORE_ERROR = False
 23    ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = False
 24    DISABLES_ALIAS_REF_EXPANSION = True
 25    INTERSECT_BINDS_TIGHTER_THAN_UNION_AND_EXCEPT = False
 26
 27    # See section 8: https://docs.oracle.com/cd/A97630_01/server.920/a96540/sql_elements9a.htm
 28    NORMALIZATION_STRATEGY = NormalizationStrategy.UPPERCASE
 29
 30    # https://docs.oracle.com/database/121/SQLRF/sql_elements004.htm#SQLRF00212
 31    # https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes
 32    TIME_MAPPING = {
 33        "D": "%u",  # Day of week (1-7)
 34        "DAY": "%A",  # name of day
 35        "DD": "%d",  # day of month (1-31)
 36        "DDD": "%j",  # day of year (1-366)
 37        "DY": "%a",  # abbreviated name of day
 38        "HH": "%I",  # Hour of day (1-12)
 39        "HH12": "%I",  # alias for HH
 40        "HH24": "%H",  # Hour of day (0-23)
 41        "IW": "%V",  # Calendar week of year (1-52 or 1-53), as defined by the ISO 8601 standard
 42        "IYYY": "%G",  # 4-digit year of the ISO 8601 week-numbering calendar
 43        "MI": "%M",  # Minute (0-59)
 44        "MM": "%m",  # Month (01-12; January = 01)
 45        "MON": "%b",  # Abbreviated name of month
 46        "MONTH": "%B",  # Name of month
 47        "SS": "%S",  # Second (0-59)
 48        "WW": "%W",  # Week of year (1-53)
 49        "YY": "%y",  # 15
 50        "YYYY": "%Y",  # 2015
 51        "FF6": "%f",  # only 6 digits are supported in python formats
 52    }
 53
 54    PSEUDOCOLUMNS = {"ROWNUM", "ROWID", "OBJECT_ID", "OBJECT_VALUE", "LEVEL"}
 55
 56    def can_quote(self, identifier: exp.Identifier, identify: str | bool = "safe") -> bool:
 57        # Disable quoting for pseudocolumns as it may break queries e.g
 58        # `WHERE "ROWNUM" = ...` does not work but `WHERE ROWNUM = ...` does
 59        return (
 60            identifier.quoted or not isinstance(identifier.parent, exp.Pseudocolumn)
 61        ) and super().can_quote(identifier, identify=identify)
 62
 63    class Tokenizer(tokens.Tokenizer):
 64        VAR_SINGLE_TOKENS = {"@", "$", "#"}
 65
 66        UNICODE_STRINGS = [
 67            (prefix + q, q)
 68            for q in t.cast(list[str], tokens.Tokenizer.QUOTES)
 69            for prefix in ("U", "u")
 70        ]
 71
 72        # https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Literals.html
 73        # Alternative quoting, e.g. q'[it's]': the delimiters are part of the quote, so the
 74        # text in between is taken as is, without escapes
 75        RAW_STRINGS = [
 76            (f"{prefix}'{start}", f"{end}'")
 77            for prefix in ("q", "Q")
 78            for start, end in (
 79                ("[", "]"),
 80                ("{", "}"),
 81                ("(", ")"),
 82                ("<", ">"),
 83                *(
 84                    (c, c)
 85                    for c in string.ascii_letters + string.digits + string.punctuation
 86                    if c not in "[{(<"
 87                ),
 88            )
 89        ]
 90        NATIONAL_RAW_STRINGS = [
 91            (prefix + start, end)
 92            for start, end in t.cast(list[tuple[str, str]], RAW_STRINGS)
 93            for prefix in ("n", "N")
 94        ]
 95        STRING_ESCAPES_ALLOWED_IN_RAW_STRINGS = False
 96
 97        NESTED_COMMENTS = False
 98
 99        KEYWORDS = {
100            **tokens.Tokenizer.KEYWORDS,
101            "(+)": TokenType.JOIN_MARKER,
102            # https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Comparison-Conditions.html
103            "^=": TokenType.NEQ,
104            "BINARY_DOUBLE": TokenType.DOUBLE,
105            "BINARY_FLOAT": TokenType.FLOAT,
106            "BULK COLLECT INTO": TokenType.BULK_COLLECT_INTO,
107            "COLUMNS": TokenType.COLUMN,
108            "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
109            "MINUS": TokenType.EXCEPT,
110            "NVARCHAR2": TokenType.NVARCHAR,
111            "ORDER SIBLINGS BY": TokenType.ORDER_SIBLINGS_BY,
112            "SAMPLE": TokenType.TABLE_SAMPLE,
113            "START": TokenType.BEGIN,
114            "SUBPARTITION": TokenType.PARTITION,
115            "TOP": TokenType.TOP,
116            "VARCHAR2": TokenType.VARCHAR,
117            "SYSTIMESTAMP": TokenType.SYSTIMESTAMP,
118        }
119
120    Parser = OracleParser
121
122    Generator = OracleGenerator
ALIAS_POST_TABLESAMPLE = True

Whether the table alias comes after tablesample.

LOCKING_READS_SUPPORTED = True
TABLESAMPLE_SIZE_IS_PERCENT = True

Whether a size in the table sample clause represents percentage.

NULL_ORDERING = 'nulls_are_large'

Default NULL ordering method to use if not explicitly set. Possible values: "nulls_are_small", "nulls_are_large", "nulls_are_last"

ON_CONDITION_EMPTY_BEFORE_ERROR = False

Whether "X ON EMPTY" should come before "X ON ERROR" (for dialects like T-SQL, MySQL, Oracle).

ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = False
DISABLES_ALIAS_REF_EXPANSION = True

Whether alias reference expansion is disabled for this dialect.

Some dialects like Oracle do NOT support referencing aliases in projections or WHERE clauses. The original expression must be repeated instead.

For example, in Oracle: SELECT y.foo AS bar, bar * 2 AS baz FROM y -- INVALID SELECT y.foo AS bar, y.foo * 2 AS baz FROM y -- VALID

INTERSECT_BINDS_TIGHTER_THAN_UNION_AND_EXCEPT = False

Whether INTERSECT binds more tightly than UNION and EXCEPT when a set operation chain isn't parenthesized. If False, all set operations have equal precedence and associate left to right.

NORMALIZATION_STRATEGY = <NormalizationStrategy.UPPERCASE: 'UPPERCASE'>

Specifies the strategy according to which identifiers should be normalized.

TIME_MAPPING: dict[str, str] = {'D': '%u', 'DAY': '%A', 'DD': '%d', 'DDD': '%j', 'DY': '%a', 'HH': '%I', 'HH12': '%I', 'HH24': '%H', 'IW': '%V', 'IYYY': '%G', 'MI': '%M', 'MM': '%m', 'MON': '%b', 'MONTH': '%B', 'SS': '%S', 'WW': '%W', 'YY': '%y', 'YYYY': '%Y', 'FF6': '%f'}

Associates this dialect's time formats with their equivalent Python strftime formats.

PSEUDOCOLUMNS: set[str] = {'LEVEL', 'OBJECT_VALUE', 'ROWID', 'OBJECT_ID', 'ROWNUM'}

Columns that are auto-generated by the engine corresponding to this dialect. For example, such columns may be excluded from SELECT * queries.

def can_quote( self, identifier: sqlglot.expressions.core.Identifier, identify: str | bool = 'safe') -> bool:
56    def can_quote(self, identifier: exp.Identifier, identify: str | bool = "safe") -> bool:
57        # Disable quoting for pseudocolumns as it may break queries e.g
58        # `WHERE "ROWNUM" = ...` does not work but `WHERE ROWNUM = ...` does
59        return (
60            identifier.quoted or not isinstance(identifier.parent, exp.Pseudocolumn)
61        ) and super().can_quote(identifier, identify=identify)

Checks if an identifier can be quoted

Arguments:
  • identifier: The identifier to check.
  • identify: True: Always returns True except for certain cases. "safe": Only returns True if the identifier is case-insensitive. "unsafe": Only returns True if the identifier is case-sensitive.
Returns:

Whether the given text can be identified.

SUPPORTS_COLUMN_JOIN_MARKS = True

Whether the old-style outer join (+) syntax is supported.

STRINGS_SUPPORT_ESCAPED_SEQUENCES: bool = False

Whether string literals support escape sequences (e.g. \n). Set by the metaclass based on the tokenizer's STRING_ESCAPES.

BYTE_STRINGS_SUPPORT_ESCAPED_SEQUENCES: bool = False

Whether byte string literals support escape sequences. Set by the metaclass based on the tokenizer's BYTE_STRING_ESCAPES.

IDENTIFIER_ESCAPED_SEQUENCES: dict[str, str] = {}

Mapping of an identifier escape char (\) to its escaped version (\\). Set by the metaclass based on the tokenizer's IDENTIFIER_ESCAPES.

INITCAP_SUPPORTS_CUSTOM_DELIMITERS = False
tokenizer_class = <class 'Oracle.Tokenizer'>
jsonpath_tokenizer_class = <class 'sqlglot.dialects.dialect.JSONPathTokenizer'>
parser_class = <class 'sqlglot.parsers.oracle.OracleParser'>
generator_class = <class 'sqlglot.generators.oracle.OracleGenerator'>
TIME_TRIE: dict = {'D': {0: True, 'A': {'Y': {0: True}}, 'D': {0: True, 'D': {0: True}}, 'Y': {0: True}}, 'H': {'H': {0: True, '1': {'2': {0: True}}, '2': {'4': {0: True}}}}, 'I': {'W': {0: True}, 'Y': {'Y': {'Y': {0: True}}}}, 'M': {'I': {0: True}, 'M': {0: True}, 'O': {'N': {0: True, 'T': {'H': {0: True}}}}}, 'S': {'S': {0: True}}, 'W': {'W': {0: True}}, 'Y': {'Y': {0: True, 'Y': {'Y': {0: True}}}}, 'F': {'F': {'6': {0: True}}}}
FORMAT_TRIE: dict = {'D': {0: True, 'A': {'Y': {0: True}}, 'D': {0: True, 'D': {0: True}}, 'Y': {0: True}}, 'H': {'H': {0: True, '1': {'2': {0: True}}, '2': {'4': {0: True}}}}, 'I': {'W': {0: True}, 'Y': {'Y': {'Y': {0: True}}}}, 'M': {'I': {0: True}, 'M': {0: True}, 'O': {'N': {0: True, 'T': {'H': {0: True}}}}}, 'S': {'S': {0: True}}, 'W': {'W': {0: True}}, 'Y': {'Y': {0: True, 'Y': {'Y': {0: True}}}}, 'F': {'F': {'6': {0: True}}}}
INVERSE_TIME_MAPPING: dict[str, str] = {'%u': 'D', '%A': 'DAY', '%d': 'DD', '%j': 'DDD', '%a': 'DY', '%I': 'HH12', '%H': 'HH24', '%V': 'IW', '%G': 'IYYY', '%M': 'MI', '%m': 'MM', '%b': 'MON', '%B': 'MONTH', '%S': 'SS', '%W': 'WW', '%y': 'YY', '%Y': 'YYYY', '%f': 'FF6', '%mstrict': 'MM', '%dstrict': 'DD', '%Hstrict': 'HH24', '%Istrict': 'HH12', '%Mstrict': 'MI', '%Sstrict': 'SS'}
INVERSE_TIME_TRIE: dict = {'%': {'u': {0: True}, 'A': {0: True}, 'd': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'j': {0: True}, 'a': {0: True}, 'I': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'H': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'V': {0: True}, 'G': {0: True}, 'M': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'm': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'b': {0: True}, 'B': {0: True}, 'S': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'W': {0: True}, 'y': {0: True}, 'Y': {0: True}, 'f': {0: True}}}
INVERSE_FORMAT_MAPPING: dict[str, str] = {'%mstrict': '%m', '%dstrict': '%d', '%Hstrict': '%H', '%Istrict': '%I', '%Mstrict': '%M', '%Sstrict': '%S'}
INVERSE_FORMAT_TRIE: dict = {'%': {'m': {'s': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'd': {'s': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'H': {'s': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'I': {'s': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'M': {'s': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'S': {'s': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}}}
INVERSE_CREATABLE_KIND_MAPPING: dict[str, str] = {}
ESCAPED_SEQUENCES: dict[str, str] = {}
QUOTE_START = "'"
QUOTE_END = "'"
IDENTIFIER_START = '"'
IDENTIFIER_END = '"'
VALID_INTERVAL_UNITS: set[str] = {'QUARTER', 'D', 'QTR', 'MILLISEC', 'DD', 'WEEKDAY', 'DAYS', 'WEEKISO', 'MONS', 'TZM', 'NS', 'DEC', 'NANOSEC', 'YYY', 'QUARTERS', 'CENTS', 'EPOCH_NANOSECOND', 'MON', 'TIMEZONE_HOUR', 'MONTH', 'HOURS', 'NSEC', 'MSECS', 'MILLENNIUM', 'WOY', 'MILLISECOND', 'EPOCH_MICROSECONDS', 'DAYOFWEEKISO', 'WY', 'WEEKOFYEAR', 'MI', 'H', 'DW_ISO', 'M', 'Y', 'DOY', 'C', 'DAYOFWEEK', 'DAY OF WEEK', 'YYYY', 'USEC', 'TIMEZONE_MINUTE', 'YY', 'WEEKOFYEAR_ISO', 'HRS', 'MINUTES', 'DECS', 'NSECOND', 'MILLENIA', 'MILS', 'DOW_ISO', 'USECONDS', 'MSEC', 'DECADE', 'MICROSEC', 'MINUTE', 'MICROSECS', 'MILLISECONDS', 'YEAR', 'YR', 'NANOSECS', 'CENTURIES', 'CENTURY', 'WK', 'DW', 'YRS', 'DECADES', 'US', 'HH', 'DAY', 'EPOCH_MILLISECOND', 'MIL', 'YEARS', 'DAYOFMONTH', 'WEEKOFYEARISO', 'S', 'WEEK', 'SECS', 'EPOCH', 'MS', 'USECOND', 'QTRS', 'MILLISECON', 'SECOND', 'MINS', 'MSECONDS', 'DAYOFWEEK_ISO', 'SEC', 'MSECOND', 'NSECONDS', 'EPOCH_NANOSECONDS', 'W', 'MM', 'EPOCH_MICROSECOND', 'EPOCH_SECONDS', 'EPOCH_SECOND', 'EPOCH_MILLISECONDS', 'MONTHS', 'SECONDS', 'DAY OF YEAR', 'MILLISECS', 'Q', 'HR', 'DOW', 'MICROSECOND', 'WEEKDAY_ISO', 'HOUR', 'USECS', 'MIN', 'WEEK_ISO', 'MICROSECONDS', 'DAYOFYEAR', 'NANOSECOND', 'TZH', 'CENT', 'DY'}
BIT_START: str | None = None
BIT_END: str | None = None
HEX_START: str | None = None
HEX_END: str | None = None
BYTE_START: str | None = None
BYTE_END: str | None = None
UNICODE_START: str | None = "U'"
UNICODE_END: str | None = "'"
class Oracle.Tokenizer(sqlglot.tokens.Tokenizer):
 63    class Tokenizer(tokens.Tokenizer):
 64        VAR_SINGLE_TOKENS = {"@", "$", "#"}
 65
 66        UNICODE_STRINGS = [
 67            (prefix + q, q)
 68            for q in t.cast(list[str], tokens.Tokenizer.QUOTES)
 69            for prefix in ("U", "u")
 70        ]
 71
 72        # https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Literals.html
 73        # Alternative quoting, e.g. q'[it's]': the delimiters are part of the quote, so the
 74        # text in between is taken as is, without escapes
 75        RAW_STRINGS = [
 76            (f"{prefix}'{start}", f"{end}'")
 77            for prefix in ("q", "Q")
 78            for start, end in (
 79                ("[", "]"),
 80                ("{", "}"),
 81                ("(", ")"),
 82                ("<", ">"),
 83                *(
 84                    (c, c)
 85                    for c in string.ascii_letters + string.digits + string.punctuation
 86                    if c not in "[{(<"
 87                ),
 88            )
 89        ]
 90        NATIONAL_RAW_STRINGS = [
 91            (prefix + start, end)
 92            for start, end in t.cast(list[tuple[str, str]], RAW_STRINGS)
 93            for prefix in ("n", "N")
 94        ]
 95        STRING_ESCAPES_ALLOWED_IN_RAW_STRINGS = False
 96
 97        NESTED_COMMENTS = False
 98
 99        KEYWORDS = {
100            **tokens.Tokenizer.KEYWORDS,
101            "(+)": TokenType.JOIN_MARKER,
102            # https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Comparison-Conditions.html
103            "^=": TokenType.NEQ,
104            "BINARY_DOUBLE": TokenType.DOUBLE,
105            "BINARY_FLOAT": TokenType.FLOAT,
106            "BULK COLLECT INTO": TokenType.BULK_COLLECT_INTO,
107            "COLUMNS": TokenType.COLUMN,
108            "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
109            "MINUS": TokenType.EXCEPT,
110            "NVARCHAR2": TokenType.NVARCHAR,
111            "ORDER SIBLINGS BY": TokenType.ORDER_SIBLINGS_BY,
112            "SAMPLE": TokenType.TABLE_SAMPLE,
113            "START": TokenType.BEGIN,
114            "SUBPARTITION": TokenType.PARTITION,
115            "TOP": TokenType.TOP,
116            "VARCHAR2": TokenType.VARCHAR,
117            "SYSTIMESTAMP": TokenType.SYSTIMESTAMP,
118        }
VAR_SINGLE_TOKENS = {'@', '$', '#'}
UNICODE_STRINGS = [("U'", "'"), ("u'", "'")]
RAW_STRINGS = [("q'[", "]'"), ("q'{", "}'"), ("q'(", ")'"), ("q'<", ">'"), ("q'a", "a'"), ("q'b", "b'"), ("q'c", "c'"), ("q'd", "d'"), ("q'e", "e'"), ("q'f", "f'"), ("q'g", "g'"), ("q'h", "h'"), ("q'i", "i'"), ("q'j", "j'"), ("q'k", "k'"), ("q'l", "l'"), ("q'm", "m'"), ("q'n", "n'"), ("q'o", "o'"), ("q'p", "p'"), ("q'q", "q'"), ("q'r", "r'"), ("q's", "s'"), ("q't", "t'"), ("q'u", "u'"), ("q'v", "v'"), ("q'w", "w'"), ("q'x", "x'"), ("q'y", "y'"), ("q'z", "z'"), ("q'A", "A'"), ("q'B", "B'"), ("q'C", "C'"), ("q'D", "D'"), ("q'E", "E'"), ("q'F", "F'"), ("q'G", "G'"), ("q'H", "H'"), ("q'I", "I'"), ("q'J", "J'"), ("q'K", "K'"), ("q'L", "L'"), ("q'M", "M'"), ("q'N", "N'"), ("q'O", "O'"), ("q'P", "P'"), ("q'Q", "Q'"), ("q'R", "R'"), ("q'S", "S'"), ("q'T", "T'"), ("q'U", "U'"), ("q'V", "V'"), ("q'W", "W'"), ("q'X", "X'"), ("q'Y", "Y'"), ("q'Z", "Z'"), ("q'0", "0'"), ("q'1", "1'"), ("q'2", "2'"), ("q'3", "3'"), ("q'4", "4'"), ("q'5", "5'"), ("q'6", "6'"), ("q'7", "7'"), ("q'8", "8'"), ("q'9", "9'"), ("q'!", "!'"), ('q\'"', '"\''), ("q'#", "#'"), ("q'$", "$'"), ("q'%", "%'"), ("q'&", "&'"), ("q''", "''"), ("q')", ")'"), ("q'*", "*'"), ("q'+", "+'"), ("q',", ",'"), ("q'-", "-'"), ("q'.", ".'"), ("q'/", "/'"), ("q':", ":'"), ("q';", ";'"), ("q'=", "='"), ("q'>", ">'"), ("q'?", "?'"), ("q'@", "@'"), ("q'\\", "\\'"), ("q']", "]'"), ("q'^", "^'"), ("q'_", "_'"), ("q'`", "`'"), ("q'|", "|'"), ("q'}", "}'"), ("q'~", "~'"), ("Q'[", "]'"), ("Q'{", "}'"), ("Q'(", ")'"), ("Q'<", ">'"), ("Q'a", "a'"), ("Q'b", "b'"), ("Q'c", "c'"), ("Q'd", "d'"), ("Q'e", "e'"), ("Q'f", "f'"), ("Q'g", "g'"), ("Q'h", "h'"), ("Q'i", "i'"), ("Q'j", "j'"), ("Q'k", "k'"), ("Q'l", "l'"), ("Q'm", "m'"), ("Q'n", "n'"), ("Q'o", "o'"), ("Q'p", "p'"), ("Q'q", "q'"), ("Q'r", "r'"), ("Q's", "s'"), ("Q't", "t'"), ("Q'u", "u'"), ("Q'v", "v'"), ("Q'w", "w'"), ("Q'x", "x'"), ("Q'y", "y'"), ("Q'z", "z'"), ("Q'A", "A'"), ("Q'B", "B'"), ("Q'C", "C'"), ("Q'D", "D'"), ("Q'E", "E'"), ("Q'F", "F'"), ("Q'G", "G'"), ("Q'H", "H'"), ("Q'I", "I'"), ("Q'J", "J'"), ("Q'K", "K'"), ("Q'L", "L'"), ("Q'M", "M'"), ("Q'N", "N'"), ("Q'O", "O'"), ("Q'P", "P'"), ("Q'Q", "Q'"), ("Q'R", "R'"), ("Q'S", "S'"), ("Q'T", "T'"), ("Q'U", "U'"), ("Q'V", "V'"), ("Q'W", "W'"), ("Q'X", "X'"), ("Q'Y", "Y'"), ("Q'Z", "Z'"), ("Q'0", "0'"), ("Q'1", "1'"), ("Q'2", "2'"), ("Q'3", "3'"), ("Q'4", "4'"), ("Q'5", "5'"), ("Q'6", "6'"), ("Q'7", "7'"), ("Q'8", "8'"), ("Q'9", "9'"), ("Q'!", "!'"), ('Q\'"', '"\''), ("Q'#", "#'"), ("Q'$", "$'"), ("Q'%", "%'"), ("Q'&", "&'"), ("Q''", "''"), ("Q')", ")'"), ("Q'*", "*'"), ("Q'+", "+'"), ("Q',", ",'"), ("Q'-", "-'"), ("Q'.", ".'"), ("Q'/", "/'"), ("Q':", ":'"), ("Q';", ";'"), ("Q'=", "='"), ("Q'>", ">'"), ("Q'?", "?'"), ("Q'@", "@'"), ("Q'\\", "\\'"), ("Q']", "]'"), ("Q'^", "^'"), ("Q'_", "_'"), ("Q'`", "`'"), ("Q'|", "|'"), ("Q'}", "}'"), ("Q'~", "~'")]
NATIONAL_RAW_STRINGS = [("nq'[", "]'"), ("Nq'[", "]'"), ("nq'{", "}'"), ("Nq'{", "}'"), ("nq'(", ")'"), ("Nq'(", ")'"), ("nq'<", ">'"), ("Nq'<", ">'"), ("nq'a", "a'"), ("Nq'a", "a'"), ("nq'b", "b'"), ("Nq'b", "b'"), ("nq'c", "c'"), ("Nq'c", "c'"), ("nq'd", "d'"), ("Nq'd", "d'"), ("nq'e", "e'"), ("Nq'e", "e'"), ("nq'f", "f'"), ("Nq'f", "f'"), ("nq'g", "g'"), ("Nq'g", "g'"), ("nq'h", "h'"), ("Nq'h", "h'"), ("nq'i", "i'"), ("Nq'i", "i'"), ("nq'j", "j'"), ("Nq'j", "j'"), ("nq'k", "k'"), ("Nq'k", "k'"), ("nq'l", "l'"), ("Nq'l", "l'"), ("nq'm", "m'"), ("Nq'm", "m'"), ("nq'n", "n'"), ("Nq'n", "n'"), ("nq'o", "o'"), ("Nq'o", "o'"), ("nq'p", "p'"), ("Nq'p", "p'"), ("nq'q", "q'"), ("Nq'q", "q'"), ("nq'r", "r'"), ("Nq'r", "r'"), ("nq's", "s'"), ("Nq's", "s'"), ("nq't", "t'"), ("Nq't", "t'"), ("nq'u", "u'"), ("Nq'u", "u'"), ("nq'v", "v'"), ("Nq'v", "v'"), ("nq'w", "w'"), ("Nq'w", "w'"), ("nq'x", "x'"), ("Nq'x", "x'"), ("nq'y", "y'"), ("Nq'y", "y'"), ("nq'z", "z'"), ("Nq'z", "z'"), ("nq'A", "A'"), ("Nq'A", "A'"), ("nq'B", "B'"), ("Nq'B", "B'"), ("nq'C", "C'"), ("Nq'C", "C'"), ("nq'D", "D'"), ("Nq'D", "D'"), ("nq'E", "E'"), ("Nq'E", "E'"), ("nq'F", "F'"), ("Nq'F", "F'"), ("nq'G", "G'"), ("Nq'G", "G'"), ("nq'H", "H'"), ("Nq'H", "H'"), ("nq'I", "I'"), ("Nq'I", "I'"), ("nq'J", "J'"), ("Nq'J", "J'"), ("nq'K", "K'"), ("Nq'K", "K'"), ("nq'L", "L'"), ("Nq'L", "L'"), ("nq'M", "M'"), ("Nq'M", "M'"), ("nq'N", "N'"), ("Nq'N", "N'"), ("nq'O", "O'"), ("Nq'O", "O'"), ("nq'P", "P'"), ("Nq'P", "P'"), ("nq'Q", "Q'"), ("Nq'Q", "Q'"), ("nq'R", "R'"), ("Nq'R", "R'"), ("nq'S", "S'"), ("Nq'S", "S'"), ("nq'T", "T'"), ("Nq'T", "T'"), ("nq'U", "U'"), ("Nq'U", "U'"), ("nq'V", "V'"), ("Nq'V", "V'"), ("nq'W", "W'"), ("Nq'W", "W'"), ("nq'X", "X'"), ("Nq'X", "X'"), ("nq'Y", "Y'"), ("Nq'Y", "Y'"), ("nq'Z", "Z'"), ("Nq'Z", "Z'"), ("nq'0", "0'"), ("Nq'0", "0'"), ("nq'1", "1'"), ("Nq'1", "1'"), ("nq'2", "2'"), ("Nq'2", "2'"), ("nq'3", "3'"), ("Nq'3", "3'"), ("nq'4", "4'"), ("Nq'4", "4'"), ("nq'5", "5'"), ("Nq'5", "5'"), ("nq'6", "6'"), ("Nq'6", "6'"), ("nq'7", "7'"), ("Nq'7", "7'"), ("nq'8", "8'"), ("Nq'8", "8'"), ("nq'9", "9'"), ("Nq'9", "9'"), ("nq'!", "!'"), ("Nq'!", "!'"), ('nq\'"', '"\''), ('Nq\'"', '"\''), ("nq'#", "#'"), ("Nq'#", "#'"), ("nq'$", "$'"), ("Nq'$", "$'"), ("nq'%", "%'"), ("Nq'%", "%'"), ("nq'&", "&'"), ("Nq'&", "&'"), ("nq''", "''"), ("Nq''", "''"), ("nq')", ")'"), ("Nq')", ")'"), ("nq'*", "*'"), ("Nq'*", "*'"), ("nq'+", "+'"), ("Nq'+", "+'"), ("nq',", ",'"), ("Nq',", ",'"), ("nq'-", "-'"), ("Nq'-", "-'"), ("nq'.", ".'"), ("Nq'.", ".'"), ("nq'/", "/'"), ("Nq'/", "/'"), ("nq':", ":'"), ("Nq':", ":'"), ("nq';", ";'"), ("Nq';", ";'"), ("nq'=", "='"), ("Nq'=", "='"), ("nq'>", ">'"), ("Nq'>", ">'"), ("nq'?", "?'"), ("Nq'?", "?'"), ("nq'@", "@'"), ("Nq'@", "@'"), ("nq'\\", "\\'"), ("Nq'\\", "\\'"), ("nq']", "]'"), ("Nq']", "]'"), ("nq'^", "^'"), ("Nq'^", "^'"), ("nq'_", "_'"), ("Nq'_", "_'"), ("nq'`", "`'"), ("Nq'`", "`'"), ("nq'|", "|'"), ("Nq'|", "|'"), ("nq'}", "}'"), ("Nq'}", "}'"), ("nq'~", "~'"), ("Nq'~", "~'"), ("nQ'[", "]'"), ("NQ'[", "]'"), ("nQ'{", "}'"), ("NQ'{", "}'"), ("nQ'(", ")'"), ("NQ'(", ")'"), ("nQ'<", ">'"), ("NQ'<", ">'"), ("nQ'a", "a'"), ("NQ'a", "a'"), ("nQ'b", "b'"), ("NQ'b", "b'"), ("nQ'c", "c'"), ("NQ'c", "c'"), ("nQ'd", "d'"), ("NQ'd", "d'"), ("nQ'e", "e'"), ("NQ'e", "e'"), ("nQ'f", "f'"), ("NQ'f", "f'"), ("nQ'g", "g'"), ("NQ'g", "g'"), ("nQ'h", "h'"), ("NQ'h", "h'"), ("nQ'i", "i'"), ("NQ'i", "i'"), ("nQ'j", "j'"), ("NQ'j", "j'"), ("nQ'k", "k'"), ("NQ'k", "k'"), ("nQ'l", "l'"), ("NQ'l", "l'"), ("nQ'm", "m'"), ("NQ'm", "m'"), ("nQ'n", "n'"), ("NQ'n", "n'"), ("nQ'o", "o'"), ("NQ'o", "o'"), ("nQ'p", "p'"), ("NQ'p", "p'"), ("nQ'q", "q'"), ("NQ'q", "q'"), ("nQ'r", "r'"), ("NQ'r", "r'"), ("nQ's", "s'"), ("NQ's", "s'"), ("nQ't", "t'"), ("NQ't", "t'"), ("nQ'u", "u'"), ("NQ'u", "u'"), ("nQ'v", "v'"), ("NQ'v", "v'"), ("nQ'w", "w'"), ("NQ'w", "w'"), ("nQ'x", "x'"), ("NQ'x", "x'"), ("nQ'y", "y'"), ("NQ'y", "y'"), ("nQ'z", "z'"), ("NQ'z", "z'"), ("nQ'A", "A'"), ("NQ'A", "A'"), ("nQ'B", "B'"), ("NQ'B", "B'"), ("nQ'C", "C'"), ("NQ'C", "C'"), ("nQ'D", "D'"), ("NQ'D", "D'"), ("nQ'E", "E'"), ("NQ'E", "E'"), ("nQ'F", "F'"), ("NQ'F", "F'"), ("nQ'G", "G'"), ("NQ'G", "G'"), ("nQ'H", "H'"), ("NQ'H", "H'"), ("nQ'I", "I'"), ("NQ'I", "I'"), ("nQ'J", "J'"), ("NQ'J", "J'"), ("nQ'K", "K'"), ("NQ'K", "K'"), ("nQ'L", "L'"), ("NQ'L", "L'"), ("nQ'M", "M'"), ("NQ'M", "M'"), ("nQ'N", "N'"), ("NQ'N", "N'"), ("nQ'O", "O'"), ("NQ'O", "O'"), ("nQ'P", "P'"), ("NQ'P", "P'"), ("nQ'Q", "Q'"), ("NQ'Q", "Q'"), ("nQ'R", "R'"), ("NQ'R", "R'"), ("nQ'S", "S'"), ("NQ'S", "S'"), ("nQ'T", "T'"), ("NQ'T", "T'"), ("nQ'U", "U'"), ("NQ'U", "U'"), ("nQ'V", "V'"), ("NQ'V", "V'"), ("nQ'W", "W'"), ("NQ'W", "W'"), ("nQ'X", "X'"), ("NQ'X", "X'"), ("nQ'Y", "Y'"), ("NQ'Y", "Y'"), ("nQ'Z", "Z'"), ("NQ'Z", "Z'"), ("nQ'0", "0'"), ("NQ'0", "0'"), ("nQ'1", "1'"), ("NQ'1", "1'"), ("nQ'2", "2'"), ("NQ'2", "2'"), ("nQ'3", "3'"), ("NQ'3", "3'"), ("nQ'4", "4'"), ("NQ'4", "4'"), ("nQ'5", "5'"), ("NQ'5", "5'"), ("nQ'6", "6'"), ("NQ'6", "6'"), ("nQ'7", "7'"), ("NQ'7", "7'"), ("nQ'8", "8'"), ("NQ'8", "8'"), ("nQ'9", "9'"), ("NQ'9", "9'"), ("nQ'!", "!'"), ("NQ'!", "!'"), ('nQ\'"', '"\''), ('NQ\'"', '"\''), ("nQ'#", "#'"), ("NQ'#", "#'"), ("nQ'$", "$'"), ("NQ'$", "$'"), ("nQ'%", "%'"), ("NQ'%", "%'"), ("nQ'&", "&'"), ("NQ'&", "&'"), ("nQ''", "''"), ("NQ''", "''"), ("nQ')", ")'"), ("NQ')", ")'"), ("nQ'*", "*'"), ("NQ'*", "*'"), ("nQ'+", "+'"), ("NQ'+", "+'"), ("nQ',", ",'"), ("NQ',", ",'"), ("nQ'-", "-'"), ("NQ'-", "-'"), ("nQ'.", ".'"), ("NQ'.", ".'"), ("nQ'/", "/'"), ("NQ'/", "/'"), ("nQ':", ":'"), ("NQ':", ":'"), ("nQ';", ";'"), ("NQ';", ";'"), ("nQ'=", "='"), ("NQ'=", "='"), ("nQ'>", ">'"), ("NQ'>", ">'"), ("nQ'?", "?'"), ("NQ'?", "?'"), ("nQ'@", "@'"), ("NQ'@", "@'"), ("nQ'\\", "\\'"), ("NQ'\\", "\\'"), ("nQ']", "]'"), ("NQ']", "]'"), ("nQ'^", "^'"), ("NQ'^", "^'"), ("nQ'_", "_'"), ("NQ'_", "_'"), ("nQ'`", "`'"), ("NQ'`", "`'"), ("nQ'|", "|'"), ("NQ'|", "|'"), ("nQ'}", "}'"), ("NQ'}", "}'"), ("nQ'~", "~'"), ("NQ'~", "~'")]
STRING_ESCAPES_ALLOWED_IN_RAW_STRINGS = False
NESTED_COMMENTS = False
KEYWORDS = {'{%': <TokenType.BLOCK_START: 73>, '{%+': <TokenType.BLOCK_START: 73>, '{%-': <TokenType.BLOCK_START: 73>, '%}': <TokenType.BLOCK_END: 74>, '+%}': <TokenType.BLOCK_END: 74>, '-%}': <TokenType.BLOCK_END: 74>, '{{+': <TokenType.BLOCK_START: 73>, '{{-': <TokenType.BLOCK_START: 73>, '+}}': <TokenType.BLOCK_END: 74>, '-}}': <TokenType.BLOCK_END: 74>, '/*+': <TokenType.HINT: 297>, '&<': <TokenType.AMP_LT: 63>, '&>': <TokenType.AMP_GT: 64>, '==': <TokenType.EQ: 28>, '::': <TokenType.DCOLON: 14>, '?::': <TokenType.QDCOLON: 375>, '||': <TokenType.DPIPE: 37>, '|>': <TokenType.PIPE_GT: 38>, '>=': <TokenType.GTE: 26>, '<=': <TokenType.LTE: 24>, '<>': <TokenType.NEQ: 29>, '!=': <TokenType.NEQ: 29>, ':=': <TokenType.COLON_EQ: 31>, '<=>': <TokenType.NULLSAFE_EQ: 30>, '->': <TokenType.ARROW: 45>, '->>': <TokenType.DARROW: 46>, '=>': <TokenType.FARROW: 47>, '#>': <TokenType.HASH_ARROW: 49>, '#>>': <TokenType.DHASH_ARROW: 50>, '<->': <TokenType.LR_ARROW: 51>, '<<->>': <TokenType.LLRR_ARROW: 52>, '&&': <TokenType.DAMP: 62>, '??': <TokenType.DQMARK: 18>, '~~~': <TokenType.GLOB: 291>, '~~': <TokenType.LIKE: 322>, '~~*': <TokenType.ILIKE: 299>, '~*': <TokenType.IRLIKE: 311>, '-|-': <TokenType.ADJACENT: 65>, 'ALL': <TokenType.ALL: 222>, 'AND': <TokenType.AND: 34>, 'ANTI': <TokenType.ANTI: 223>, 'ANY': <TokenType.ANY: 224>, 'ASC': <TokenType.ASC: 227>, 'AS': <TokenType.ALIAS: 220>, 'ASOF': <TokenType.ASOF: 228>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 230>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 230>, 'BEGIN': <TokenType.BEGIN: 231>, 'BETWEEN': <TokenType.BETWEEN: 232>, 'CACHE': <TokenType.CACHE: 234>, 'UNCACHE': <TokenType.UNCACHE: 419>, 'CASE': <TokenType.CASE: 235>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 237>, 'COLLATE': <TokenType.COLLATE: 238>, 'COLUMN': <TokenType.COLUMN: 81>, 'COMMIT': <TokenType.COMMIT: 241>, 'CONNECT BY': <TokenType.CONNECT_BY: 243>, 'CONSTRAINT': <TokenType.CONSTRAINT: 244>, 'COPY': <TokenType.COPY: 245>, 'CREATE': <TokenType.CREATE: 246>, 'CROSS': <TokenType.CROSS: 247>, 'CUBE': <TokenType.CUBE: 248>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 249>, 'CURRENT_SCHEMA': <TokenType.CURRENT_SCHEMA: 251>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 252>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 253>, 'CURRENT_USER': <TokenType.CURRENT_USER: 254>, 'CURRENT_CATALOG': <TokenType.CURRENT_CATALOG: 257>, 'DATABASE': <TokenType.DATABASE: 80>, 'DEFAULT': <TokenType.DEFAULT: 259>, 'DELETE': <TokenType.DELETE: 260>, 'DESC': <TokenType.DESC: 261>, 'DESCRIBE': <TokenType.DESCRIBE: 262>, 'DISTINCT': <TokenType.DISTINCT: 266>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 267>, 'DIV': <TokenType.DIV: 268>, 'DROP': <TokenType.DROP: 269>, 'ELSE': <TokenType.ELSE: 270>, 'END': <TokenType.END: 271>, 'ENUM': <TokenType.ENUM: 207>, 'ESCAPE': <TokenType.ESCAPE: 272>, 'EXCEPT': <TokenType.EXCEPT: 273>, 'EXECUTE': <TokenType.EXECUTE: 274>, 'EXISTS': <TokenType.EXISTS: 275>, 'FALSE': <TokenType.FALSE: 276>, 'FETCH': <TokenType.FETCH: 277>, 'FILTER': <TokenType.FILTER: 280>, 'FILE': <TokenType.FILE: 278>, 'FIRST': <TokenType.FIRST: 282>, 'FULL': <TokenType.FULL: 288>, 'FUNCTION': <TokenType.FUNCTION: 289>, 'FOR': <TokenType.FOR: 283>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 285>, 'FORMAT': <TokenType.FORMAT: 286>, 'FROM': <TokenType.FROM: 287>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 173>, 'GEOMETRY': <TokenType.GEOMETRY: 176>, 'GLOB': <TokenType.GLOB: 291>, 'GROUP BY': <TokenType.GROUP_BY: 294>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 295>, 'HAVING': <TokenType.HAVING: 296>, 'ILIKE': <TokenType.ILIKE: 299>, 'IN': <TokenType.IN: 300>, 'INDEX': <TokenType.INDEX: 301>, 'INET': <TokenType.INET: 202>, 'INNER': <TokenType.INNER: 303>, 'INSERT': <TokenType.INSERT: 304>, 'INTERVAL': <TokenType.INTERVAL: 308>, 'INTERSECT': <TokenType.INTERSECT: 307>, 'INTO': <TokenType.INTO: 309>, 'IS': <TokenType.IS: 312>, 'ISNULL': <TokenType.ISNULL: 313>, 'JOIN': <TokenType.JOIN: 314>, 'KEEP': <TokenType.KEEP: 316>, 'KILL': <TokenType.KILL: 318>, 'LATERAL': <TokenType.LATERAL: 320>, 'LEFT': <TokenType.LEFT: 321>, 'LIKE': <TokenType.LIKE: 322>, 'LIMIT': <TokenType.LIMIT: 323>, 'LOAD': <TokenType.LOAD: 325>, 'LOCALTIME': <TokenType.LOCALTIME: 180>, 'LOCALTIMESTAMP': <TokenType.LOCALTIMESTAMP: 181>, 'LOCK': <TokenType.LOCK: 326>, 'MERGE': <TokenType.MERGE: 332>, 'NAMESPACE': <TokenType.NAMESPACE: 445>, 'NATURAL': <TokenType.NATURAL: 335>, 'NEXT': <TokenType.NEXT: 336>, 'NOT': <TokenType.NOT: 27>, 'NOTNULL': <TokenType.NOTNULL: 338>, 'NULL': <TokenType.NULL: 339>, 'OBJECT': <TokenType.OBJECT: 200>, 'REF': <TokenType.REF: 201>, 'OFFSET': <TokenType.OFFSET: 341>, 'ON': <TokenType.ON: 342>, 'OR': <TokenType.OR: 35>, 'XOR': <TokenType.XOR: 66>, 'ORDER BY': <TokenType.ORDER_BY: 345>, 'ORDINALITY': <TokenType.ORDINALITY: 348>, 'OUT': <TokenType.OUT: 349>, 'OUTER': <TokenType.OUTER: 351>, 'OVER': <TokenType.OVER: 352>, 'OVERLAPS': <TokenType.OVERLAPS: 353>, 'OVERWRITE': <TokenType.OVERWRITE: 354>, 'PARTITION': <TokenType.PARTITION: 356>, 'PARTITION BY': <TokenType.PARTITION_BY: 357>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 357>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 357>, 'PERCENT': <TokenType.PERCENT: 359>, 'PIVOT': <TokenType.PIVOT: 360>, 'PRAGMA': <TokenType.PRAGMA: 365>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 367>, 'PROCEDURE': <TokenType.PROCEDURE: 368>, 'OPERATOR': <TokenType.OPERATOR: 344>, 'QUALIFY': <TokenType.QUALIFY: 373>, 'RANGE': <TokenType.RANGE: 376>, 'RECURSIVE': <TokenType.RECURSIVE: 377>, 'REGEXP': <TokenType.RLIKE: 385>, 'RENAME': <TokenType.RENAME: 379>, 'REPLACE': <TokenType.REPLACE: 380>, 'RETURNING': <TokenType.RETURNING: 381>, 'REFERENCES': <TokenType.REFERENCES: 383>, 'RIGHT': <TokenType.RIGHT: 384>, 'RLIKE': <TokenType.RLIKE: 385>, 'ROLLBACK': <TokenType.ROLLBACK: 387>, 'ROLLUP': <TokenType.ROLLUP: 388>, 'ROW': <TokenType.ROW: 389>, 'ROWS': <TokenType.ROWS: 390>, 'SCHEMA': <TokenType.SCHEMA: 83>, 'SELECT': <TokenType.SELECT: 392>, 'SEMI': <TokenType.SEMI: 393>, 'SESSION': <TokenType.SESSION: 59>, 'SESSION_USER': <TokenType.SESSION_USER: 61>, 'SET': <TokenType.SET: 397>, 'SETTINGS': <TokenType.SETTINGS: 398>, 'SHOW': <TokenType.SHOW: 399>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 400>, 'SOME': <TokenType.SOME: 401>, 'SORT BY': <TokenType.SORT_BY: 402>, 'SQL SECURITY': <TokenType.SQL_SECURITY: 404>, 'STRAIGHT_JOIN': <TokenType.STRAIGHT_JOIN: 407>, 'TABLE': <TokenType.TABLE: 84>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 410>, 'TEMP': <TokenType.TEMPORARY: 412>, 'TEMPORARY': <TokenType.TEMPORARY: 412>, 'THEN': <TokenType.THEN: 414>, 'TRUE': <TokenType.TRUE: 415>, 'TRUNCATE': <TokenType.TRUNCATE: 416>, 'TRIGGER': <TokenType.TRIGGER: 417>, 'UNION': <TokenType.UNION: 421>, 'UNKNOWN': <TokenType.UNKNOWN: 216>, 'UNNEST': <TokenType.UNNEST: 422>, 'UNPIVOT': <TokenType.UNPIVOT: 423>, 'UPDATE': <TokenType.UPDATE: 424>, 'USE': <TokenType.USE: 425>, 'USING': <TokenType.USING: 426>, 'UUID': <TokenType.UUID: 172>, 'VALUES': <TokenType.VALUES: 427>, 'VIEW': <TokenType.VIEW: 429>, 'VOLATILE': <TokenType.VOLATILE: 431>, 'WHEN': <TokenType.WHEN: 433>, 'WHERE': <TokenType.WHERE: 434>, 'WINDOW': <TokenType.WINDOW: 435>, 'WITH': <TokenType.WITH: 436>, 'APPLY': <TokenType.APPLY: 225>, 'ARRAY': <TokenType.ARRAY: 226>, 'BIT': <TokenType.BIT: 98>, 'BOOL': <TokenType.BOOLEAN: 99>, 'BOOLEAN': <TokenType.BOOLEAN: 99>, 'BYTE': <TokenType.TINYINT: 100>, 'MEDIUMINT': <TokenType.MEDIUMINT: 104>, 'INT1': <TokenType.TINYINT: 100>, 'TINYINT': <TokenType.TINYINT: 100>, 'INT16': <TokenType.SMALLINT: 102>, 'SHORT': <TokenType.SMALLINT: 102>, 'SMALLINT': <TokenType.SMALLINT: 102>, 'HUGEINT': <TokenType.INT128: 111>, 'UHUGEINT': <TokenType.UINT128: 112>, 'INT2': <TokenType.SMALLINT: 102>, 'INTEGER': <TokenType.INT: 106>, 'INT': <TokenType.INT: 106>, 'INT4': <TokenType.INT: 106>, 'INT32': <TokenType.INT: 106>, 'INT64': <TokenType.BIGINT: 108>, 'INT128': <TokenType.INT128: 111>, 'INT256': <TokenType.INT256: 113>, 'LONG': <TokenType.BIGINT: 108>, 'BIGINT': <TokenType.BIGINT: 108>, 'INT8': <TokenType.TINYINT: 100>, 'UINT': <TokenType.UINT: 107>, 'UINT128': <TokenType.UINT128: 112>, 'UINT256': <TokenType.UINT256: 114>, 'DEC': <TokenType.DECIMAL: 118>, 'DECIMAL': <TokenType.DECIMAL: 118>, 'DECIMAL32': <TokenType.DECIMAL32: 119>, 'DECIMAL64': <TokenType.DECIMAL64: 120>, 'DECIMAL128': <TokenType.DECIMAL128: 121>, 'DECIMAL256': <TokenType.DECIMAL256: 122>, 'DECFLOAT': <TokenType.DECFLOAT: 123>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 125>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 125>, 'BIGNUM': <TokenType.BIGNUM: 110>, 'LIST': <TokenType.LIST: 324>, 'MAP': <TokenType.MAP: 327>, 'NULLABLE': <TokenType.NULLABLE: 175>, 'NUMBER': <TokenType.DECIMAL: 118>, 'NUMERIC': <TokenType.DECIMAL: 118>, 'FIXED': <TokenType.DECIMAL: 118>, 'REAL': <TokenType.FLOAT: 115>, 'FLOAT': <TokenType.FLOAT: 115>, 'FLOAT4': <TokenType.FLOAT: 115>, 'FLOAT8': <TokenType.DOUBLE: 116>, 'DOUBLE': <TokenType.DOUBLE: 116>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 116>, 'JSON': <TokenType.JSON: 142>, 'JSONB': <TokenType.JSONB: 143>, 'CHAR': <TokenType.CHAR: 126>, 'CHARACTER': <TokenType.CHAR: 126>, 'CHAR VARYING': <TokenType.VARCHAR: 128>, 'CHARACTER VARYING': <TokenType.VARCHAR: 128>, 'NCHAR': <TokenType.NCHAR: 127>, 'VARCHAR': <TokenType.VARCHAR: 128>, 'VARCHAR2': <TokenType.VARCHAR: 128>, 'NVARCHAR': <TokenType.NVARCHAR: 129>, 'NVARCHAR2': <TokenType.NVARCHAR: 129>, 'BPCHAR': <TokenType.BPCHAR: 130>, 'STR': <TokenType.TEXT: 131>, 'STRING': <TokenType.TEXT: 131>, 'TEXT': <TokenType.TEXT: 131>, 'LONGTEXT': <TokenType.LONGTEXT: 133>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 132>, 'TINYTEXT': <TokenType.TINYTEXT: 138>, 'CLOB': <TokenType.TEXT: 131>, 'LONGVARCHAR': <TokenType.TEXT: 131>, 'BINARY': <TokenType.BINARY: 140>, 'BLOB': <TokenType.VARBINARY: 141>, 'LONGBLOB': <TokenType.LONGBLOB: 136>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 135>, 'TINYBLOB': <TokenType.TINYBLOB: 137>, 'BYTEA': <TokenType.VARBINARY: 141>, 'VARBINARY': <TokenType.VARBINARY: 141>, 'TIME': <TokenType.TIME: 144>, 'TIMETZ': <TokenType.TIMETZ: 145>, 'TIME_NS': <TokenType.TIME_NS: 146>, 'TIMESTAMP': <TokenType.TIMESTAMP: 147>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 148>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 149>, 'TIMESTAMP_LTZ': <TokenType.TIMESTAMPLTZ: 149>, 'TIMESTAMPNTZ': <TokenType.TIMESTAMPNTZ: 150>, 'TIMESTAMP_NTZ': <TokenType.TIMESTAMPNTZ: 150>, 'DATE': <TokenType.DATE: 158>, 'DATETIME': <TokenType.DATETIME: 154>, 'INT4RANGE': <TokenType.INT4RANGE: 160>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 161>, 'INT8RANGE': <TokenType.INT8RANGE: 162>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 163>, 'NUMRANGE': <TokenType.NUMRANGE: 164>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 165>, 'TSRANGE': <TokenType.TSRANGE: 166>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 167>, 'TSTZRANGE': <TokenType.TSTZRANGE: 168>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 169>, 'DATERANGE': <TokenType.DATERANGE: 170>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 171>, 'UNIQUE': <TokenType.UNIQUE: 437>, 'VECTOR': <TokenType.VECTOR: 217>, 'STRUCT': <TokenType.STRUCT: 408>, 'SEQUENCE': <TokenType.SEQUENCE: 395>, 'VARIANT': <TokenType.VARIANT: 199>, 'ALTER': <TokenType.ALTER: 221>, 'ANALYZE': <TokenType.ANALYZE: 444>, 'CALL': <TokenType.COMMAND: 239>, 'COMMENT': <TokenType.COMMENT: 240>, 'EXPLAIN': <TokenType.COMMAND: 239>, 'GRANT': <TokenType.GRANT: 293>, 'REVOKE': <TokenType.REVOKE: 382>, 'OPTIMIZE': <TokenType.COMMAND: 239>, 'PREPARE': <TokenType.COMMAND: 239>, 'VACUUM': <TokenType.COMMAND: 239>, 'USER-DEFINED': <TokenType.USERDEFINED: 194>, '(+)': <TokenType.JOIN_MARKER: 315>, '^=': <TokenType.NEQ: 29>, 'BINARY_DOUBLE': <TokenType.DOUBLE: 116>, 'BINARY_FLOAT': <TokenType.FLOAT: 115>, 'BULK COLLECT INTO': <TokenType.BULK_COLLECT_INTO: 233>, 'COLUMNS': <TokenType.COLUMN: 81>, 'MATCH_RECOGNIZE': <TokenType.MATCH_RECOGNIZE: 330>, 'MINUS': <TokenType.EXCEPT: 273>, 'ORDER SIBLINGS BY': <TokenType.ORDER_SIBLINGS_BY: 346>, 'SAMPLE': <TokenType.TABLE_SAMPLE: 410>, 'START': <TokenType.BEGIN: 231>, 'SUBPARTITION': <TokenType.PARTITION: 356>, 'TOP': <TokenType.TOP: 413>, 'SYSTIMESTAMP': <TokenType.SYSTIMESTAMP: 182>}
BYTE_STRING_ESCAPES: ClassVar[list[str]] = ["'"]