Edit on GitHub

sqlglot.dialects.drill

View Source

 1from __future__ import annotations
 2
 3
 4from sqlglot import tokens
 5from sqlglot.dialects.dialect import Dialect
 6from sqlglot.generators.drill import DrillGenerator
 7from sqlglot.parsers.drill import DrillParser
 8
 9
10class Drill(Dialect):
11    NORMALIZE_FUNCTIONS: bool | str = False
12    ORIGINAL_NAME_META_KEY = "drill_name"
13    NULL_ORDERING = "nulls_are_last"
14    DATE_FORMAT = "'yyyy-MM-dd'"
15    DATEINT_FORMAT = "'yyyyMMdd'"
16    TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"
17    SUPPORTS_USER_DEFINED_TYPES = False
18    TYPED_DIVISION = True
19    CONCAT_COALESCE = True
20    CONCAT_WS_COALESCE = True
21
22    TIME_MAPPING = {
23        "y": "%Y",
24        "Y": "%Y",
25        "YYYY": "%Y",
26        "yyyy": "%Y",
27        "YY": "%y",
28        "yy": "%y",
29        "MMMM": "%B",
30        "MMM": "%b",
31        "MM": "%m",
32        "M": "%-m",
33        "dd": "%d",
34        "d": "%-d",
35        "HH": "%H",
36        "H": "%-H",
37        "hh": "%I",
38        "h": "%-I",
39        "mm": "%M",
40        "m": "%-M",
41        "ss": "%S",
42        "s": "%-S",
43        "SSSSSS": "%f",
44        "a": "%p",
45        "DD": "%j",
46        "D": "%-j",
47        "E": "%a",
48        "EE": "%a",
49        "EEE": "%a",
50        "EEEE": "%A",
51        "''T''": "T",
52    }
53
54    class Tokenizer(tokens.Tokenizer):
55        IDENTIFIERS = ["`"]
56        STRING_ESCAPES = ["'"]
57
58        KEYWORDS = tokens.Tokenizer.KEYWORDS.copy()
59        KEYWORDS.pop("/*+")
60
61    Parser = DrillParser
62
63    Generator = DrillGenerator

class Drill(sqlglot.dialects.dialect.Dialect): View Source

11class Drill(Dialect):
12    NORMALIZE_FUNCTIONS: bool | str = False
13    ORIGINAL_NAME_META_KEY = "drill_name"
14    NULL_ORDERING = "nulls_are_last"
15    DATE_FORMAT = "'yyyy-MM-dd'"
16    DATEINT_FORMAT = "'yyyyMMdd'"
17    TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"
18    SUPPORTS_USER_DEFINED_TYPES = False
19    TYPED_DIVISION = True
20    CONCAT_COALESCE = True
21    CONCAT_WS_COALESCE = True
22
23    TIME_MAPPING = {
24        "y": "%Y",
25        "Y": "%Y",
26        "YYYY": "%Y",
27        "yyyy": "%Y",
28        "YY": "%y",
29        "yy": "%y",
30        "MMMM": "%B",
31        "MMM": "%b",
32        "MM": "%m",
33        "M": "%-m",
34        "dd": "%d",
35        "d": "%-d",
36        "HH": "%H",
37        "H": "%-H",
38        "hh": "%I",
39        "h": "%-I",
40        "mm": "%M",
41        "m": "%-M",
42        "ss": "%S",
43        "s": "%-S",
44        "SSSSSS": "%f",
45        "a": "%p",
46        "DD": "%j",
47        "D": "%-j",
48        "E": "%a",
49        "EE": "%a",
50        "EEE": "%a",
51        "EEEE": "%A",
52        "''T''": "T",
53    }
54
55    class Tokenizer(tokens.Tokenizer):
56        IDENTIFIERS = ["`"]
57        STRING_ESCAPES = ["'"]
58
59        KEYWORDS = tokens.Tokenizer.KEYWORDS.copy()
60        KEYWORDS.pop("/*+")
61
62    Parser = DrillParser
63
64    Generator = DrillGenerator

NORMALIZE_FUNCTIONS: bool | str = False

Determines how function names are going to be normalized.

Possible values:

"upper" or True: Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.

ORIGINAL_NAME_META_KEY = 'drill_name'

Dialect-specific metadata key for preserving original function names, or None to disable. Only generators using the same key reuse these names, allowing round trips of aliases that share an AST node, e.g. JSON_VALUE vs JSON_EXTRACT_SCALAR in BigQuery.

NULL_ORDERING = 'nulls_are_last'

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

DATE_FORMAT = "'yyyy-MM-dd'"

DATEINT_FORMAT = "'yyyyMMdd'"

TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"

SUPPORTS_USER_DEFINED_TYPES = False

Whether user-defined data types are supported.

TYPED_DIVISION = True

Whether the behavior of a / b depends on the types of a and b. False means a / b is always float division. True means a / b is integer division if both a and b are integers.

CONCAT_COALESCE = True

A NULL arg in CONCAT yields NULL by default, but in some dialects it yields an empty string.

CONCAT_WS_COALESCE = True

A NULL arg in CONCAT_WS yields NULL by default, but in some dialects it is skipped.

TIME_MAPPING = {'y': '%Y', 'Y': '%Y', 'YYYY': '%Y', 'yyyy': '%Y', 'YY': '%y', 'yy': '%y', 'MMMM': '%B', 'MMM': '%b', 'MM': '%m', 'M': '%-m', 'dd': '%d', 'd': '%-d', 'HH': '%H', 'H': '%-H', 'hh': '%I', 'h': '%-I', 'mm': '%M', 'm': '%-M', 'ss': '%S', 's': '%-S', 'SSSSSS': '%f', 'a': '%p', 'DD': '%j', 'D': '%-j', 'E': '%a', 'EE': '%a', 'EEE': '%a', 'EEEE': '%A', "''T''": 'T'}

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

Parser = <class 'sqlglot.parsers.drill.DrillParser'>

Generator = <class 'sqlglot.generators.drill.DrillGenerator'>

SUPPORTS_COLUMN_JOIN_MARKS = False

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 'Drill.Tokenizer'>

jsonpath_tokenizer_class = <class 'sqlglot.dialects.dialect.JSONPathTokenizer'>

parser_class = <class 'sqlglot.parsers.drill.DrillParser'>

generator_class = <class 'sqlglot.generators.drill.DrillGenerator'>

TIME_TRIE: dict = {'y': {0: True, 'y': {'y': {'y': {0: True}}, 0: True}}, 'Y': {0: True, 'Y': {'Y': {'Y': {0: True}}, 0: True}}, 'M': {'M': {'M': {'M': {0: True}, 0: True}, 0: True}, 0: True}, 'd': {'d': {0: True}, 0: True}, 'H': {'H': {0: True}, 0: True}, 'h': {'h': {0: True}, 0: True}, 'm': {'m': {0: True}, 0: True}, 's': {'s': {0: True}, 0: True}, 'S': {'S': {'S': {'S': {'S': {'S': {0: True}}}}}}, 'a': {0: True}, 'D': {'D': {0: True}, 0: True}, 'E': {0: True, 'E': {0: True, 'E': {0: True, 'E': {0: True}}}}, "'": {"'": {'T': {"'": {"'": {0: True}}}}}}

FORMAT_TRIE: dict = {'y': {0: True, 'y': {'y': {'y': {0: True}}, 0: True}}, 'Y': {0: True, 'Y': {'Y': {'Y': {0: True}}, 0: True}}, 'M': {'M': {'M': {'M': {0: True}, 0: True}, 0: True}, 0: True}, 'd': {'d': {0: True}, 0: True}, 'H': {'H': {0: True}, 0: True}, 'h': {'h': {0: True}, 0: True}, 'm': {'m': {0: True}, 0: True}, 's': {'s': {0: True}, 0: True}, 'S': {'S': {'S': {'S': {'S': {'S': {0: True}}}}}}, 'a': {0: True}, 'D': {'D': {0: True}, 0: True}, 'E': {0: True, 'E': {0: True, 'E': {0: True, 'E': {0: True}}}}, "'": {"'": {'T': {"'": {"'": {0: True}}}}}}

INVERSE_TIME_MAPPING: dict[str, str] = {'%Y': 'yyyy', '%y': 'yy', '%B': 'MMMM', '%b': 'MMM', '%m': 'MM', '%-m': 'M', '%d': 'dd', '%-d': 'd', '%H': 'HH', '%-H': 'H', '%I': 'hh', '%-I': 'h', '%M': 'mm', '%-M': 'm', '%S': 'ss', '%-S': 's', '%f': 'SSSSSS', '%p': 'a', '%j': 'DD', '%-j': 'D', '%a': 'EEE', '%A': 'EEEE', 'T': "''T''", '%mstrict': 'MM', '%dstrict': 'dd', '%Hstrict': 'HH', '%Istrict': 'hh', '%Mstrict': 'mm', '%Sstrict': 'ss'}

INVERSE_TIME_TRIE: dict = {'%': {'Y': {0: True}, 'y': {0: True}, 'B': {0: True}, 'b': {0: True}, 'm': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, '-': {'m': {0: True}, 'd': {0: True}, 'H': {0: True}, 'I': {0: True}, 'M': {0: True}, 'S': {0: True}, 'j': {0: True}}, 'd': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'H': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'I': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'M': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'S': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'f': {0: True}, 'p': {0: True}, 'j': {0: True}, 'a': {0: True}, 'A': {0: True}}, 'T': {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] = {'YR', 'WK', 'NSECOND', 'MI', 'QUARTER', 'CENTS', 'WOY', 'SECS', 'DAYOFWEEK_ISO', 'MINS', 'MM', 'MILLENIA', 'Y', 'DAYOFMONTH', 'HR', 'YYYY', 'MONS', 'TZM', 'MICROSECOND', 'EPOCH_SECOND', 'YEARS', 'MICROSECONDS', 'WEEKOFYEAR_ISO', 'MICROSEC', 'US', 'H', 'M', 'DW_ISO', 'HH', 'DAYOFWEEK', 'USECOND', 'DEC', 'C', 'MILS', 'DAYOFYEAR', 'DECS', 'WEEK_ISO', 'DD', 'TIMEZONE_MINUTE', 'MON', 'MIL', 'MSECOND', 'USECS', 'SEC', 'YYY', 'QUARTERS', 'EPOCH_MILLISECOND', 'DAY', 'W', 'MONTH', 'DW', 'HOUR', 'MILLENNIUM', 'NANOSECS', 'MONTHS', 'NSECONDS', 'TIMEZONE_HOUR', 'YY', 'DY', 'DAY OF YEAR', 'NS', 'MICROSECS', 'EPOCH_MILLISECONDS', 'HOURS', 'MIN', 'NANOSEC', 'MILLISECS', 'EPOCH_MICROSECONDS', 'Q', 'USEC', 'NANOSECOND', 'EPOCH', 'CENTURIES', 'EPOCH_SECONDS', 'HRS', 'MILLISECONDS', 'QTRS', 'TZH', 'MS', 'MINUTES', 'WEEKDAY_ISO', 'YEAR', 'WEEK', 'MSECS', 'EPOCH_NANOSECOND', 'MSEC', 'DOW_ISO', 'MINUTE', 'WY', 'NSEC', 'CENTURY', 'DAYS', 'S', 'MILLISEC', 'YRS', 'QTR', 'WEEKOFYEAR', 'DOW', 'MILLISECON', 'DAY OF WEEK', 'SECOND', 'D', 'USECONDS', 'WEEKISO', 'DECADE', 'DAYOFWEEKISO', 'WEEKDAY', 'CENT', 'WEEKOFYEARISO', 'SECONDS', 'EPOCH_MICROSECOND', 'EPOCH_NANOSECONDS', 'MSECONDS', 'DOY', 'MILLISECOND', 'DECADES'}

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 = None

UNICODE_END: str | None = None

class Drill.Tokenizer(sqlglot.tokens.Tokenizer): View Source

55    class Tokenizer(tokens.Tokenizer):
56        IDENTIFIERS = ["`"]
57        STRING_ESCAPES = ["'"]
58
59        KEYWORDS = tokens.Tokenizer.KEYWORDS.copy()
60        KEYWORDS.pop("/*+")

IDENTIFIERS = ['`']

STRING_ESCAPES = ["'"]

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.AMP_LT: 63>, '&>': <TokenType.AMP_GT: 64>, '==': <TokenType.EQ: 28>, '::': <TokenType.DCOLON: 14>, '?::': <TokenType.QDCOLON: 370>, '||': <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: 287>, '~~': <TokenType.LIKE: 318>, '~~*': <TokenType.ILIKE: 295>, '~*': <TokenType.IRLIKE: 307>, '-|-': <TokenType.ADJACENT: 65>, 'ALL': <TokenType.ALL: 220>, 'AND': <TokenType.AND: 34>, 'ANTI': <TokenType.ANTI: 221>, 'ANY': <TokenType.ANY: 222>, 'ASC': <TokenType.ASC: 225>, 'AS': <TokenType.ALIAS: 218>, 'ASOF': <TokenType.ASOF: 226>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 228>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 228>, 'BEGIN': <TokenType.BEGIN: 229>, 'BETWEEN': <TokenType.BETWEEN: 230>, 'CACHE': <TokenType.CACHE: 232>, 'UNCACHE': <TokenType.UNCACHE: 414>, 'CASE': <TokenType.CASE: 233>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 235>, 'COLLATE': <TokenType.COLLATE: 236>, 'COLUMN': <TokenType.COLUMN: 81>, 'COMMIT': <TokenType.COMMIT: 239>, 'CONNECT BY': <TokenType.CONNECT_BY: 240>, 'CONSTRAINT': <TokenType.CONSTRAINT: 241>, 'COPY': <TokenType.COPY: 242>, 'CREATE': <TokenType.CREATE: 243>, 'CROSS': <TokenType.CROSS: 244>, 'CUBE': <TokenType.CUBE: 245>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 246>, 'CURRENT_SCHEMA': <TokenType.CURRENT_SCHEMA: 248>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 249>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 250>, 'CURRENT_USER': <TokenType.CURRENT_USER: 251>, 'CURRENT_CATALOG': <TokenType.CURRENT_CATALOG: 254>, 'DATABASE': <TokenType.DATABASE: 80>, 'DEFAULT': <TokenType.DEFAULT: 256>, 'DELETE': <TokenType.DELETE: 257>, 'DESC': <TokenType.DESC: 258>, 'DESCRIBE': <TokenType.DESCRIBE: 259>, 'DISTINCT': <TokenType.DISTINCT: 262>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 263>, 'DIV': <TokenType.DIV: 264>, 'DROP': <TokenType.DROP: 265>, 'ELSE': <TokenType.ELSE: 266>, 'END': <TokenType.END: 267>, 'ENUM': <TokenType.ENUM: 205>, 'ESCAPE': <TokenType.ESCAPE: 268>, 'EXCEPT': <TokenType.EXCEPT: 269>, 'EXECUTE': <TokenType.EXECUTE: 270>, 'EXISTS': <TokenType.EXISTS: 271>, 'FALSE': <TokenType.FALSE: 272>, 'FETCH': <TokenType.FETCH: 273>, 'FILTER': <TokenType.FILTER: 276>, 'FILE': <TokenType.FILE: 274>, 'FIRST': <TokenType.FIRST: 278>, 'FULL': <TokenType.FULL: 284>, 'FUNCTION': <TokenType.FUNCTION: 285>, 'FOR': <TokenType.FOR: 279>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 281>, 'FORMAT': <TokenType.FORMAT: 282>, 'FROM': <TokenType.FROM: 283>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 172>, 'GEOMETRY': <TokenType.GEOMETRY: 175>, 'GLOB': <TokenType.GLOB: 287>, 'GROUP BY': <TokenType.GROUP_BY: 290>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 291>, 'HAVING': <TokenType.HAVING: 292>, 'ILIKE': <TokenType.ILIKE: 295>, 'IN': <TokenType.IN: 296>, 'INDEX': <TokenType.INDEX: 297>, 'INET': <TokenType.INET: 200>, 'INNER': <TokenType.INNER: 299>, 'INSERT': <TokenType.INSERT: 300>, 'INTERVAL': <TokenType.INTERVAL: 304>, 'INTERSECT': <TokenType.INTERSECT: 303>, 'INTO': <TokenType.INTO: 305>, 'IS': <TokenType.IS: 308>, 'ISNULL': <TokenType.ISNULL: 309>, 'JOIN': <TokenType.JOIN: 310>, 'KEEP': <TokenType.KEEP: 312>, 'KILL': <TokenType.KILL: 314>, 'LATERAL': <TokenType.LATERAL: 316>, 'LEFT': <TokenType.LEFT: 317>, 'LIKE': <TokenType.LIKE: 318>, 'LIMIT': <TokenType.LIMIT: 319>, 'LOAD': <TokenType.LOAD: 321>, 'LOCALTIME': <TokenType.LOCALTIME: 179>, 'LOCALTIMESTAMP': <TokenType.LOCALTIMESTAMP: 180>, 'LOCK': <TokenType.LOCK: 322>, 'MERGE': <TokenType.MERGE: 328>, 'NAMESPACE': <TokenType.NAMESPACE: 440>, 'NATURAL': <TokenType.NATURAL: 331>, 'NEXT': <TokenType.NEXT: 332>, 'NOT': <TokenType.NOT: 27>, 'NOTNULL': <TokenType.NOTNULL: 334>, 'NULL': <TokenType.NULL: 335>, 'OBJECT': <TokenType.OBJECT: 199>, 'OFFSET': <TokenType.OFFSET: 337>, 'ON': <TokenType.ON: 338>, 'OR': <TokenType.OR: 35>, 'XOR': <TokenType.XOR: 66>, 'ORDER BY': <TokenType.ORDER_BY: 341>, 'ORDINALITY': <TokenType.ORDINALITY: 344>, 'OUT': <TokenType.OUT: 345>, 'OUTER': <TokenType.OUTER: 347>, 'OVER': <TokenType.OVER: 348>, 'OVERLAPS': <TokenType.OVERLAPS: 349>, 'OVERWRITE': <TokenType.OVERWRITE: 350>, 'PARTITION': <TokenType.PARTITION: 352>, 'PARTITION BY': <TokenType.PARTITION_BY: 353>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 353>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 353>, 'PERCENT': <TokenType.PERCENT: 354>, 'PIVOT': <TokenType.PIVOT: 355>, 'PRAGMA': <TokenType.PRAGMA: 360>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 362>, 'PROCEDURE': <TokenType.PROCEDURE: 363>, 'OPERATOR': <TokenType.OPERATOR: 340>, 'QUALIFY': <TokenType.QUALIFY: 368>, 'RANGE': <TokenType.RANGE: 371>, 'RECURSIVE': <TokenType.RECURSIVE: 372>, 'REGEXP': <TokenType.RLIKE: 380>, 'RENAME': <TokenType.RENAME: 374>, 'REPLACE': <TokenType.REPLACE: 375>, 'RETURNING': <TokenType.RETURNING: 376>, 'REFERENCES': <TokenType.REFERENCES: 378>, 'RIGHT': <TokenType.RIGHT: 379>, 'RLIKE': <TokenType.RLIKE: 380>, 'ROLLBACK': <TokenType.ROLLBACK: 382>, 'ROLLUP': <TokenType.ROLLUP: 383>, 'ROW': <TokenType.ROW: 384>, 'ROWS': <TokenType.ROWS: 385>, 'SCHEMA': <TokenType.SCHEMA: 83>, 'SELECT': <TokenType.SELECT: 387>, 'SEMI': <TokenType.SEMI: 388>, 'SESSION': <TokenType.SESSION: 59>, 'SESSION_USER': <TokenType.SESSION_USER: 61>, 'SET': <TokenType.SET: 392>, 'SETTINGS': <TokenType.SETTINGS: 393>, 'SHOW': <TokenType.SHOW: 394>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 395>, 'SOME': <TokenType.SOME: 396>, 'SORT BY': <TokenType.SORT_BY: 397>, 'SQL SECURITY': <TokenType.SQL_SECURITY: 399>, 'STRAIGHT_JOIN': <TokenType.STRAIGHT_JOIN: 402>, 'TABLE': <TokenType.TABLE: 84>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 405>, 'TEMP': <TokenType.TEMPORARY: 407>, 'TEMPORARY': <TokenType.TEMPORARY: 407>, 'THEN': <TokenType.THEN: 409>, 'TRUE': <TokenType.TRUE: 410>, 'TRUNCATE': <TokenType.TRUNCATE: 411>, 'TRIGGER': <TokenType.TRIGGER: 412>, 'UNION': <TokenType.UNION: 416>, 'UNKNOWN': <TokenType.UNKNOWN: 214>, 'UNNEST': <TokenType.UNNEST: 417>, 'UNPIVOT': <TokenType.UNPIVOT: 418>, 'UPDATE': <TokenType.UPDATE: 419>, 'USE': <TokenType.USE: 420>, 'USING': <TokenType.USING: 421>, 'UUID': <TokenType.UUID: 171>, 'VALUES': <TokenType.VALUES: 422>, 'VIEW': <TokenType.VIEW: 424>, 'VOLATILE': <TokenType.VOLATILE: 426>, 'WHEN': <TokenType.WHEN: 428>, 'WHERE': <TokenType.WHERE: 429>, 'WINDOW': <TokenType.WINDOW: 430>, 'WITH': <TokenType.WITH: 431>, 'APPLY': <TokenType.APPLY: 223>, 'ARRAY': <TokenType.ARRAY: 224>, 'BIT': <TokenType.BIT: 97>, 'BOOL': <TokenType.BOOLEAN: 98>, 'BOOLEAN': <TokenType.BOOLEAN: 98>, 'BYTE': <TokenType.TINYINT: 99>, 'MEDIUMINT': <TokenType.MEDIUMINT: 103>, 'INT1': <TokenType.TINYINT: 99>, 'TINYINT': <TokenType.TINYINT: 99>, 'INT16': <TokenType.SMALLINT: 101>, 'SHORT': <TokenType.SMALLINT: 101>, 'SMALLINT': <TokenType.SMALLINT: 101>, 'HUGEINT': <TokenType.INT128: 110>, 'UHUGEINT': <TokenType.UINT128: 111>, 'INT2': <TokenType.SMALLINT: 101>, 'INTEGER': <TokenType.INT: 105>, 'INT': <TokenType.INT: 105>, 'INT4': <TokenType.INT: 105>, 'INT32': <TokenType.INT: 105>, 'INT64': <TokenType.BIGINT: 107>, 'INT128': <TokenType.INT128: 110>, 'INT256': <TokenType.INT256: 112>, 'LONG': <TokenType.BIGINT: 107>, 'BIGINT': <TokenType.BIGINT: 107>, 'INT8': <TokenType.TINYINT: 99>, 'UINT': <TokenType.UINT: 106>, 'UINT128': <TokenType.UINT128: 111>, 'UINT256': <TokenType.UINT256: 113>, 'DEC': <TokenType.DECIMAL: 117>, 'DECIMAL': <TokenType.DECIMAL: 117>, 'DECIMAL32': <TokenType.DECIMAL32: 118>, 'DECIMAL64': <TokenType.DECIMAL64: 119>, 'DECIMAL128': <TokenType.DECIMAL128: 120>, 'DECIMAL256': <TokenType.DECIMAL256: 121>, 'DECFLOAT': <TokenType.DECFLOAT: 122>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 124>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 124>, 'BIGNUM': <TokenType.BIGNUM: 109>, 'LIST': <TokenType.LIST: 320>, 'MAP': <TokenType.MAP: 323>, 'NULLABLE': <TokenType.NULLABLE: 174>, 'NUMBER': <TokenType.DECIMAL: 117>, 'NUMERIC': <TokenType.DECIMAL: 117>, 'FIXED': <TokenType.DECIMAL: 117>, 'REAL': <TokenType.FLOAT: 114>, 'FLOAT': <TokenType.FLOAT: 114>, 'FLOAT4': <TokenType.FLOAT: 114>, 'FLOAT8': <TokenType.DOUBLE: 115>, 'DOUBLE': <TokenType.DOUBLE: 115>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 115>, 'JSON': <TokenType.JSON: 141>, 'JSONB': <TokenType.JSONB: 142>, 'CHAR': <TokenType.CHAR: 125>, 'CHARACTER': <TokenType.CHAR: 125>, 'CHAR VARYING': <TokenType.VARCHAR: 127>, 'CHARACTER VARYING': <TokenType.VARCHAR: 127>, 'NCHAR': <TokenType.NCHAR: 126>, 'VARCHAR': <TokenType.VARCHAR: 127>, 'VARCHAR2': <TokenType.VARCHAR: 127>, 'NVARCHAR': <TokenType.NVARCHAR: 128>, 'NVARCHAR2': <TokenType.NVARCHAR: 128>, 'BPCHAR': <TokenType.BPCHAR: 129>, 'STR': <TokenType.TEXT: 130>, 'STRING': <TokenType.TEXT: 130>, 'TEXT': <TokenType.TEXT: 130>, 'LONGTEXT': <TokenType.LONGTEXT: 132>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 131>, 'TINYTEXT': <TokenType.TINYTEXT: 137>, 'CLOB': <TokenType.TEXT: 130>, 'LONGVARCHAR': <TokenType.TEXT: 130>, 'BINARY': <TokenType.BINARY: 139>, 'BLOB': <TokenType.VARBINARY: 140>, 'LONGBLOB': <TokenType.LONGBLOB: 135>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 134>, 'TINYBLOB': <TokenType.TINYBLOB: 136>, 'BYTEA': <TokenType.VARBINARY: 140>, 'VARBINARY': <TokenType.VARBINARY: 140>, 'TIME': <TokenType.TIME: 143>, 'TIMETZ': <TokenType.TIMETZ: 144>, 'TIME_NS': <TokenType.TIME_NS: 145>, 'TIMESTAMP': <TokenType.TIMESTAMP: 146>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 147>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 148>, 'TIMESTAMP_LTZ': <TokenType.TIMESTAMPLTZ: 148>, 'TIMESTAMPNTZ': <TokenType.TIMESTAMPNTZ: 149>, 'TIMESTAMP_NTZ': <TokenType.TIMESTAMPNTZ: 149>, 'DATE': <TokenType.DATE: 157>, 'DATETIME': <TokenType.DATETIME: 153>, 'INT4RANGE': <TokenType.INT4RANGE: 159>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 160>, 'INT8RANGE': <TokenType.INT8RANGE: 161>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 162>, 'NUMRANGE': <TokenType.NUMRANGE: 163>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 164>, 'TSRANGE': <TokenType.TSRANGE: 165>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 166>, 'TSTZRANGE': <TokenType.TSTZRANGE: 167>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 168>, 'DATERANGE': <TokenType.DATERANGE: 169>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 170>, 'UNIQUE': <TokenType.UNIQUE: 432>, 'VECTOR': <TokenType.VECTOR: 215>, 'STRUCT': <TokenType.STRUCT: 403>, 'SEQUENCE': <TokenType.SEQUENCE: 390>, 'VARIANT': <TokenType.VARIANT: 198>, 'ALTER': <TokenType.ALTER: 219>, 'ANALYZE': <TokenType.ANALYZE: 439>, 'CALL': <TokenType.COMMAND: 237>, 'COMMENT': <TokenType.COMMENT: 238>, 'EXPLAIN': <TokenType.COMMAND: 237>, 'GRANT': <TokenType.GRANT: 289>, 'REVOKE': <TokenType.REVOKE: 377>, 'OPTIMIZE': <TokenType.COMMAND: 237>, 'PREPARE': <TokenType.COMMAND: 237>, 'VACUUM': <TokenType.COMMAND: 237>, 'USER-DEFINED': <TokenType.USERDEFINED: 193>}

BYTE_STRING_ESCAPES: ClassVar[list[str]] = ["'"]

Inherited Members

sqlglot.tokens.Tokenizer: Tokenizer; SINGLE_TOKENS; BIT_STRINGS; BYTE_STRINGS; HEX_STRINGS; RAW_STRINGS; HEREDOC_STRINGS; UNICODE_STRINGS; QUOTES; VAR_SINGLE_TOKENS; IDENTIFIER_ESCAPES; HEREDOC_TAG_IS_IDENTIFIER; HEREDOC_STRING_ALTERNATIVE; STRING_ESCAPES_ALLOWED_IN_RAW_STRINGS; NUMERIC_ESCAPES; DROP_UNKNOWN_ESCAPES; NUMERIC_ESCAPES_ARE_BYTES; LONE_SURROGATE_REPLACEMENT; NESTED_COMMENTS; DASH_COMMENT_REQUIRES_BOUNDARY; COMMENTS_TERMINATE_AT_NEWLINE_ONLY; HINT_START; TOKENS_PRECEDING_HINT; COMMANDS; COMMAND_PREFIX_TOKENS; NUMERIC_LITERALS; NUMBERS_CAN_HAVE_DECIMALS; COMMENTS; dialect; tokenize; sql; size; tokens