Edit on GitHub

sqlglot.dialects.postgres

  1from __future__ import annotations
  2
  3from sqlglot import exp, tokens
  4from sqlglot.dialects.dialect import Dialect
  5from sqlglot.generators.postgres import PostgresGenerator
  6from sqlglot.parsers.postgres import PostgresParser
  7from sqlglot.tokens import TokenType
  8from sqlglot.typing.postgres import EXPRESSION_METADATA
  9
 10
 11class Postgres(Dialect):
 12    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
 13    INDEX_OFFSET = 1
 14    ASCII_ONLY_NORMALIZATION = True
 15    # Normalizing `x IS NOT NULL` to `NOT x IS NULL` is unsafe due to row values,
 16    # e.g. `ROW(1, NULL) IS NOT NULL` is false whereas `NOT ROW(1, NULL) IS NULL` is true
 17    NORMALIZE_NOT_NULL = False
 18    TYPED_DIVISION = True
 19    CONCAT_COALESCE = True
 20    CONCAT_WS_COALESCE = True
 21    NULL_ORDERING = "nulls_are_large"
 22    SUPPORTS_LIMIT_ALL = True
 23    TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'"
 24    TABLESAMPLE_SIZE_IS_PERCENT = True
 25    TABLES_REFERENCEABLE_AS_COLUMNS = True
 26
 27    DEFAULT_FUNCTIONS_COLUMN_NAMES = {
 28        exp.ExplodingGenerateSeries: "generate_series",
 29    }
 30
 31    TIME_MAPPING = {
 32        "d": "%u",  # 1-based day of week
 33        "D": "%u",  # 1-based day of week
 34        "dd": "%d",  # day of month
 35        "DD": "%d",  # day of month
 36        "ddd": "%j",  # zero padded day of year
 37        "DDD": "%j",  # zero padded day of year
 38        "FMDD": "%-d",  # - is no leading zero for Python; same for FM in postgres
 39        "FMDDD": "%-j",  # day of year
 40        "FMHH12": "%-I",  # 9
 41        "FMHH24": "%-H",  # 9
 42        "FMMI": "%-M",  # Minute
 43        "FMMM": "%-m",  # 1
 44        "FMSS": "%-S",  # Second
 45        "HH12": "%I",  # 09
 46        "HH24": "%H",  # 09
 47        "mi": "%M",  # zero padded minute
 48        "MI": "%M",  # zero padded minute
 49        "mm": "%m",  # 01
 50        "MM": "%m",  # 01
 51        "OF": "%z",  # utc offset
 52        "ss": "%S",  # zero padded second
 53        "SS": "%S",  # zero padded second
 54        "TMDay": "%A",  # TM is locale dependent
 55        "TMDy": "%a",
 56        "TMMon": "%b",  # Sep
 57        "TMMonth": "%B",  # September
 58        "day": "%Aenlower",  # tuesday
 59        "dy": "%aenlower",  # tue
 60        "TZ": "%Z",  # uppercase timezone name
 61        "US": "%f",  # zero padded microsecond
 62        "ww": "%U",  # 1-based week of year
 63        "WW": "%U",  # 1-based week of year
 64        "yy": "%y",  # 15
 65        "YY": "%y",  # 15
 66        "yyy": "%Ythree",  # 015
 67        "YYY": "%Ythree",  # 015
 68        "yyyy": "%Y",  # 2015
 69        "YYYY": "%Y",  # 2015
 70    }
 71
 72    UNESCAPED_SEQUENCES = {"\\a": "a"}
 73
 74    class Tokenizer(tokens.Tokenizer):
 75        NUMERIC_ESCAPES = {
 76            "x": (16, 1, 2, 0xFF),
 77            "u": (16, 4, 4, 0xFFFF),
 78            "U": (16, 8, 8, 0x10FFFF),
 79            "0": (8, 1, 3, 0o777),
 80        }
 81        NUMERIC_ESCAPES_ARE_BYTES = True
 82        DROP_UNKNOWN_ESCAPES = True
 83        BIT_STRINGS = [("b'", "'"), ("B'", "'")]
 84        HEX_STRINGS = [("x'", "'"), ("X'", "'")]
 85        BYTE_STRINGS = [("e'", "'"), ("E'", "'")]
 86        UNICODE_STRINGS = [("U&'", "'"), ("u&'", "'")]
 87        BYTE_STRING_ESCAPES = ["'", "\\"]
 88        HEREDOC_STRINGS = ["$"]
 89
 90        HEREDOC_TAG_IS_IDENTIFIER = True
 91        HEREDOC_STRING_ALTERNATIVE = TokenType.PARAMETER
 92
 93        COMMANDS = {*tokens.Tokenizer.COMMANDS, TokenType.LOCK}
 94
 95        KEYWORDS = {
 96            **tokens.Tokenizer.KEYWORDS,
 97            "~": TokenType.RLIKE,
 98            "@@": TokenType.DAT,
 99            "@?": TokenType.AT_QMARK,
100            "@>": TokenType.AT_GT,
101            "<@": TokenType.LT_AT,
102            "?&": TokenType.QMARK_AMP,
103            "?|": TokenType.QMARK_PIPE,
104            "#-": TokenType.HASH_DASH,
105            "|/": TokenType.PIPE_SLASH,
106            "||/": TokenType.DPIPE_SLASH,
107            "^@": TokenType.CARET_AT,
108            "BEGIN": TokenType.BEGIN,
109            "BIGSERIAL": TokenType.BIGSERIAL,
110            "CSTRING": TokenType.PSEUDO_TYPE,
111            "DECLARE": TokenType.COMMAND,
112            "DO": TokenType.COMMAND,
113            "EXEC": TokenType.COMMAND,
114            "HSTORE": TokenType.HSTORE,
115            "INT8": TokenType.BIGINT,
116            "MONEY": TokenType.MONEY,
117            "NAME": TokenType.NAME,
118            "OID": TokenType.OBJECT_IDENTIFIER,
119            "ONLY": TokenType.ONLY,
120            "POINT": TokenType.POINT,
121            "REFRESH": TokenType.COMMAND,
122            "REINDEX": TokenType.COMMAND,
123            "RESET": TokenType.COMMAND,
124            "SERIAL": TokenType.SERIAL,
125            "SMALLSERIAL": TokenType.SMALLSERIAL,
126            "TEMP": TokenType.TEMPORARY,
127            "TYPE": TokenType.TYPE,
128            "REGCLASS": TokenType.OBJECT_IDENTIFIER,
129            "REGCOLLATION": TokenType.OBJECT_IDENTIFIER,
130            "REGCONFIG": TokenType.OBJECT_IDENTIFIER,
131            "REGDICTIONARY": TokenType.OBJECT_IDENTIFIER,
132            "REGNAMESPACE": TokenType.OBJECT_IDENTIFIER,
133            "REGOPER": TokenType.OBJECT_IDENTIFIER,
134            "REGOPERATOR": TokenType.OBJECT_IDENTIFIER,
135            "REGPROC": TokenType.OBJECT_IDENTIFIER,
136            "REGPROCEDURE": TokenType.OBJECT_IDENTIFIER,
137            "REGROLE": TokenType.OBJECT_IDENTIFIER,
138            "REGTYPE": TokenType.OBJECT_IDENTIFIER,
139            "FLOAT": TokenType.DOUBLE,
140            "XML": TokenType.XML,
141            "VARIADIC": TokenType.VARIADIC,
142            "INOUT": TokenType.INOUT,
143        }
144        KEYWORDS.pop("/*+")
145        KEYWORDS.pop("DIV")
146
147        SINGLE_TOKENS = {
148            **tokens.Tokenizer.SINGLE_TOKENS,
149            "$": TokenType.HEREDOC_STRING,
150        }
151
152        VAR_SINGLE_TOKENS = {"$"}
153
154    Parser = PostgresParser
155
156    Generator = PostgresGenerator
class Postgres(sqlglot.dialects.dialect.Dialect):
 12class Postgres(Dialect):
 13    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
 14    INDEX_OFFSET = 1
 15    ASCII_ONLY_NORMALIZATION = True
 16    # Normalizing `x IS NOT NULL` to `NOT x IS NULL` is unsafe due to row values,
 17    # e.g. `ROW(1, NULL) IS NOT NULL` is false whereas `NOT ROW(1, NULL) IS NULL` is true
 18    NORMALIZE_NOT_NULL = False
 19    TYPED_DIVISION = True
 20    CONCAT_COALESCE = True
 21    CONCAT_WS_COALESCE = True
 22    NULL_ORDERING = "nulls_are_large"
 23    SUPPORTS_LIMIT_ALL = True
 24    TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'"
 25    TABLESAMPLE_SIZE_IS_PERCENT = True
 26    TABLES_REFERENCEABLE_AS_COLUMNS = True
 27
 28    DEFAULT_FUNCTIONS_COLUMN_NAMES = {
 29        exp.ExplodingGenerateSeries: "generate_series",
 30    }
 31
 32    TIME_MAPPING = {
 33        "d": "%u",  # 1-based day of week
 34        "D": "%u",  # 1-based day of week
 35        "dd": "%d",  # day of month
 36        "DD": "%d",  # day of month
 37        "ddd": "%j",  # zero padded day of year
 38        "DDD": "%j",  # zero padded day of year
 39        "FMDD": "%-d",  # - is no leading zero for Python; same for FM in postgres
 40        "FMDDD": "%-j",  # day of year
 41        "FMHH12": "%-I",  # 9
 42        "FMHH24": "%-H",  # 9
 43        "FMMI": "%-M",  # Minute
 44        "FMMM": "%-m",  # 1
 45        "FMSS": "%-S",  # Second
 46        "HH12": "%I",  # 09
 47        "HH24": "%H",  # 09
 48        "mi": "%M",  # zero padded minute
 49        "MI": "%M",  # zero padded minute
 50        "mm": "%m",  # 01
 51        "MM": "%m",  # 01
 52        "OF": "%z",  # utc offset
 53        "ss": "%S",  # zero padded second
 54        "SS": "%S",  # zero padded second
 55        "TMDay": "%A",  # TM is locale dependent
 56        "TMDy": "%a",
 57        "TMMon": "%b",  # Sep
 58        "TMMonth": "%B",  # September
 59        "day": "%Aenlower",  # tuesday
 60        "dy": "%aenlower",  # tue
 61        "TZ": "%Z",  # uppercase timezone name
 62        "US": "%f",  # zero padded microsecond
 63        "ww": "%U",  # 1-based week of year
 64        "WW": "%U",  # 1-based week of year
 65        "yy": "%y",  # 15
 66        "YY": "%y",  # 15
 67        "yyy": "%Ythree",  # 015
 68        "YYY": "%Ythree",  # 015
 69        "yyyy": "%Y",  # 2015
 70        "YYYY": "%Y",  # 2015
 71    }
 72
 73    UNESCAPED_SEQUENCES = {"\\a": "a"}
 74
 75    class Tokenizer(tokens.Tokenizer):
 76        NUMERIC_ESCAPES = {
 77            "x": (16, 1, 2, 0xFF),
 78            "u": (16, 4, 4, 0xFFFF),
 79            "U": (16, 8, 8, 0x10FFFF),
 80            "0": (8, 1, 3, 0o777),
 81        }
 82        NUMERIC_ESCAPES_ARE_BYTES = True
 83        DROP_UNKNOWN_ESCAPES = True
 84        BIT_STRINGS = [("b'", "'"), ("B'", "'")]
 85        HEX_STRINGS = [("x'", "'"), ("X'", "'")]
 86        BYTE_STRINGS = [("e'", "'"), ("E'", "'")]
 87        UNICODE_STRINGS = [("U&'", "'"), ("u&'", "'")]
 88        BYTE_STRING_ESCAPES = ["'", "\\"]
 89        HEREDOC_STRINGS = ["$"]
 90
 91        HEREDOC_TAG_IS_IDENTIFIER = True
 92        HEREDOC_STRING_ALTERNATIVE = TokenType.PARAMETER
 93
 94        COMMANDS = {*tokens.Tokenizer.COMMANDS, TokenType.LOCK}
 95
 96        KEYWORDS = {
 97            **tokens.Tokenizer.KEYWORDS,
 98            "~": TokenType.RLIKE,
 99            "@@": TokenType.DAT,
100            "@?": TokenType.AT_QMARK,
101            "@>": TokenType.AT_GT,
102            "<@": TokenType.LT_AT,
103            "?&": TokenType.QMARK_AMP,
104            "?|": TokenType.QMARK_PIPE,
105            "#-": TokenType.HASH_DASH,
106            "|/": TokenType.PIPE_SLASH,
107            "||/": TokenType.DPIPE_SLASH,
108            "^@": TokenType.CARET_AT,
109            "BEGIN": TokenType.BEGIN,
110            "BIGSERIAL": TokenType.BIGSERIAL,
111            "CSTRING": TokenType.PSEUDO_TYPE,
112            "DECLARE": TokenType.COMMAND,
113            "DO": TokenType.COMMAND,
114            "EXEC": TokenType.COMMAND,
115            "HSTORE": TokenType.HSTORE,
116            "INT8": TokenType.BIGINT,
117            "MONEY": TokenType.MONEY,
118            "NAME": TokenType.NAME,
119            "OID": TokenType.OBJECT_IDENTIFIER,
120            "ONLY": TokenType.ONLY,
121            "POINT": TokenType.POINT,
122            "REFRESH": TokenType.COMMAND,
123            "REINDEX": TokenType.COMMAND,
124            "RESET": TokenType.COMMAND,
125            "SERIAL": TokenType.SERIAL,
126            "SMALLSERIAL": TokenType.SMALLSERIAL,
127            "TEMP": TokenType.TEMPORARY,
128            "TYPE": TokenType.TYPE,
129            "REGCLASS": TokenType.OBJECT_IDENTIFIER,
130            "REGCOLLATION": TokenType.OBJECT_IDENTIFIER,
131            "REGCONFIG": TokenType.OBJECT_IDENTIFIER,
132            "REGDICTIONARY": TokenType.OBJECT_IDENTIFIER,
133            "REGNAMESPACE": TokenType.OBJECT_IDENTIFIER,
134            "REGOPER": TokenType.OBJECT_IDENTIFIER,
135            "REGOPERATOR": TokenType.OBJECT_IDENTIFIER,
136            "REGPROC": TokenType.OBJECT_IDENTIFIER,
137            "REGPROCEDURE": TokenType.OBJECT_IDENTIFIER,
138            "REGROLE": TokenType.OBJECT_IDENTIFIER,
139            "REGTYPE": TokenType.OBJECT_IDENTIFIER,
140            "FLOAT": TokenType.DOUBLE,
141            "XML": TokenType.XML,
142            "VARIADIC": TokenType.VARIADIC,
143            "INOUT": TokenType.INOUT,
144        }
145        KEYWORDS.pop("/*+")
146        KEYWORDS.pop("DIV")
147
148        SINGLE_TOKENS = {
149            **tokens.Tokenizer.SINGLE_TOKENS,
150            "$": TokenType.HEREDOC_STRING,
151        }
152
153        VAR_SINGLE_TOKENS = {"$"}
154
155    Parser = PostgresParser
156
157    Generator = PostgresGenerator
EXPRESSION_METADATA = {<class 'sqlglot.expressions.core.Add'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Adjacent'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.And'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayContainedBy'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayContains'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayContainsAll'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayOverlaps'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayPosition'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Binary'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseAnd'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseLeftShift'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseOr'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseRightShift'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseXor'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Collate'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Connector'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.Corr'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.DPipe'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.core.Distance'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.DistanceNd'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Div'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.Dot'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.EQ'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Escape'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.ExtendsLeft'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.ExtendsRight'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.GT'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.GTE'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Glob'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.ILike'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.IntDiv'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Is'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONArrayContains'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBContains'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBContainsAllTopKeys'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBContainsAnyTopKeys'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBContainsTopKey'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBDeleteAtPath'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBExtract'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBExtractScalar'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBPathExists'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONExtract'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONExtractScalar'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Kwarg'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.LT'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.LTE'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Like'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Match'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Mod'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Mul'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.NEQ'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.NestedJSONSelect'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.NullSafeEQ'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.NullSafeNEQ'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Operator'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Or'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Overlaps'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Pow'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.core.PropertyEQ'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.string.RegexpFullMatch'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.string.RegexpILike'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.RegexpLike'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.SimilarTo'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Sub'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Xor'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Alias'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseNot'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.IgnoreNulls'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Neg'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Not'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Paren'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.PivotAlias'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.RespectNulls'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Unary'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.DenseRank'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.array.ArraySize'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.temporal.UnixSeconds'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.aggregate.Ntile'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.aggregate.Rank'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.core.ApproxDistinct'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.temporal.UnixMillis'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.temporal.UnixMicros'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.aggregate.CountIf'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.aggregate.RowNumber'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.functions.Int64'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.string.FromBase32'>: {'returns': <DType.BINARY: 'BINARY'>}, <class 'sqlglot.expressions.string.FromBase64'>: {'returns': <DType.BINARY: 'BINARY'>}, <class 'sqlglot.expressions.string.Contains'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.functions.Exists'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.Boolean'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.aggregate.LogicalOr'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.aggregate.LogicalAnd'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.string.StartsWith'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.Between'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.math.IsInf'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.Any'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.string.EndsWith'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.In'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.All'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.math.IsNan'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.temporal.CurrentDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.DateStrToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.LastDay'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.TsOrDsToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.DateFromParts'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.Date'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.TimeStrToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.DiToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.StrToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.Datetime'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.temporal.DatetimeSub'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.temporal.CurrentDatetime'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.temporal.DatetimeAdd'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.math.Round'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Asin'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Pi'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Ln'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Tanh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.VariancePop'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Sinh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.CumeDist'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Cot'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.CovarPop'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.SafeDivide'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Cos'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Quantile'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Skewness'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Radians'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Atanh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.StddevPop'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Avg'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Asinh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.functions.Rand'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.string.ToDouble'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Acosh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Exp'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Log'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Cbrt'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Tan'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Variance'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Sqrt'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.CovarSamp'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Sin'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Cosh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.ApproxQuantile'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Kurtosis'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Stddev'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Acos'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.StddevSamp'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.PercentRank'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Degrees'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Atan'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.PercentileCont'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.string.Ascii'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.UnixDate'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DateToDi'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.Levenshtein'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.Unicode'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.math.Getbit'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.TsOrDiToDi'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DayOfMonth'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.math.Sign'>: {'annotator': <function _annotate_math_function>}, <class 'sqlglot.expressions.string.StrPosition'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.Quarter'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.TimeDiff'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.TimestampDiff'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.Hour'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.BitLength'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DatetimeDiff'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.Length'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DayOfYear'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DayOfWeek'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.MakeInterval'>: {'returns': <DType.INTERVAL: 'INTERVAL'>}, <class 'sqlglot.expressions.datatypes.Interval'>: {'returns': <DType.INTERVAL: 'INTERVAL'>}, <class 'sqlglot.expressions.temporal.JustifyInterval'>: {'returns': <DType.INTERVAL: 'INTERVAL'>}, <class 'sqlglot.expressions.temporal.JustifyHours'>: {'returns': <DType.INTERVAL: 'INTERVAL'>}, <class 'sqlglot.expressions.temporal.JustifyDays'>: {'returns': <DType.INTERVAL: 'INTERVAL'>}, <class 'sqlglot.expressions.json.ParseJSON'>: {'returns': <DType.JSON: 'JSON'>}, <class 'sqlglot.expressions.temporal.CurrentTime'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.Localtime'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.Time'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.TimeSub'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.TimeAdd'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.TimestampLtzFromParts'>: {'returns': <DType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>}, <class 'sqlglot.expressions.temporal.TimestampTzFromParts'>: {'returns': <DType.TIMESTAMPTZ: 'TIMESTAMPTZ'>}, <class 'sqlglot.expressions.temporal.CurrentTimestampLTZ'>: {'returns': <DType.TIMESTAMPTZ: 'TIMESTAMPTZ'>}, <class 'sqlglot.expressions.temporal.TimeStrToTime'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.UnixToTime'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.CurrentTimestamp'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.TimestampSub'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.StrToTime'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.TimestampAdd'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.Day'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.WeekOfYear'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.Week'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.YearOfWeek'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.DayOfWeekIso'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.YearOfWeekIso'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.Month'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.Year'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.UnixToStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.SHA2'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.MD5'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.SHA'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.Monthname'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.ToBase64'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Concat'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.query.RawString'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Space'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.UnixToTimeStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.TsOrDsToDateStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.aggregate.GroupConcat'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.Dayname'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Translate'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.TimeToTimeStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Initcap'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Substring'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.String'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.SessionUser'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentVersion'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentCatalog'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentUser'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.ConcatWs'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.ToBase32'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Chr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.DateToDateStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Lower'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Upper'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentSchema'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Trim'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.core.Typeof'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentRole'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Repeat'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.array.ArrayToString'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.TimeToStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.math.Floor'>: {'annotator': <function _annotate_math_function>}, <class 'sqlglot.expressions.math.Ceil'>: {'annotator': <function _annotate_math_function>}, <class 'sqlglot.expressions.aggregate.AnyValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.math.Abs'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.NthValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Filter'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.ArrayConcatAgg'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.SortArray'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.query.Window'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.query.Order'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.LastValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.HavingMax'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArraySlice'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.query.Limit'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.FirstValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayReverse'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.Max'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Coalesce'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayConcat'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Least'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.Min'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Greatest'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayFirst'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayLast'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Anonymous'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.DateTrunc'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.temporal.DateSub'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.temporal.DateAdd'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Cast'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.TryCast'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.Map'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.VarMap'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.Array'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.aggregate.ArrayAgg'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.Bracket'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.functions.Case'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.aggregate.Count'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.DateDiff'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.datatypes.DataType'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.Distinct'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.array.Explode'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.Extract'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.query.HexString'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.array.GenerateSeries'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.GenerateDateArray'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.GenerateTimestampArray'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.functions.If'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.aggregate.Lag'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.aggregate.Lead'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.Literal'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.Null'>: {'returns': <DType.NULL: 'NULL'>}, <class 'sqlglot.expressions.functions.Nullif'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.array.Struct'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.aggregate.Sum'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.Timestamp'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.array.ToMap'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.array.Unnest'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.WithinGroup'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.query.Subquery'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.functions.WidthBucket'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.RegexpReplace'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.Overlay'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.Right'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.Hex'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.Reverse'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.Left'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.Format'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.Replace'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.SplitPart'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.Pad'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.Encode'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.Normalize'>: {'returns': <DType.TEXT: 'TEXT'>}, <class 'sqlglot.expressions.string.Decode'>: {'returns': <DType.VARBINARY: 'VARBINARY'>}, <class 'sqlglot.expressions.temporal.TimeFromParts'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.Localtimestamp'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.TimestampFromParts'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.math.BitwiseXorAgg'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.math.BitwiseOrAgg'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.math.BitwiseAndAgg'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.string.ToNumber'>: {'returns': <DType.DECIMAL: 'DECIMAL'>}}
INDEX_OFFSET = 1

The base index offset for arrays.

ASCII_ONLY_NORMALIZATION = True

Whether identifiers are only normalized with respect to ASCII characters, e.g. Ä and ä are different identifiers in DuckDB, but the same identifier in Spark.

NORMALIZE_NOT_NULL = False
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.

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"

SUPPORTS_LIMIT_ALL = True

Whether LIMIT ALL is supported (equivalent to no limit) as in Postgres.

TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'"
TABLESAMPLE_SIZE_IS_PERCENT = True

Whether a size in the table sample clause represents percentage.

TABLES_REFERENCEABLE_AS_COLUMNS = True

Whether table names can be referenced as columns (treated as structs).

BigQuery allows tables to be referenced as columns in queries, automatically treating them as struct values containing all the table's columns.

For example, in BigQuery: SELECT t FROM my_table AS t -- Returns entire row as a struct

DEFAULT_FUNCTIONS_COLUMN_NAMES: dict[type[sqlglot.expressions.core.Func], str | tuple[str, ...]] = {<class 'sqlglot.expressions.array.ExplodingGenerateSeries'>: 'generate_series'}

Maps function expressions to their default output column name(s).

For example, in Postgres, generate_series function outputs a column named "generate_series" by default, so we map the ExplodingGenerateSeries expression to "generate_series" string.

TIME_MAPPING: dict[str, str] = {'d': '%u', 'D': '%u', 'dd': '%d', 'DD': '%d', 'ddd': '%j', 'DDD': '%j', 'FMDD': '%-d', 'FMDDD': '%-j', 'FMHH12': '%-I', 'FMHH24': '%-H', 'FMMI': '%-M', 'FMMM': '%-m', 'FMSS': '%-S', 'HH12': '%I', 'HH24': '%H', 'mi': '%M', 'MI': '%M', 'mm': '%m', 'MM': '%m', 'OF': '%z', 'ss': '%S', 'SS': '%S', 'TMDay': '%A', 'TMDy': '%a', 'TMMon': '%b', 'TMMonth': '%B', 'day': '%Aenlower', 'dy': '%aenlower', 'TZ': '%Z', 'US': '%f', 'ww': '%U', 'WW': '%U', 'yy': '%y', 'YY': '%y', 'yyy': '%Ythree', 'YYY': '%Ythree', 'yyyy': '%Y', 'YYYY': '%Y'}

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

UNESCAPED_SEQUENCES: dict[str, str] = {'\\a': 'a', '\\b': '\x08', '\\f': '\x0c', '\\n': '\n', '\\r': '\r', '\\t': '\t', '\\v': '\x0b', '\\\\': '\\'}

Mapping of an escaped sequence (\n) to its unescaped version ( ).

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

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 'Postgres.Tokenizer'>
jsonpath_tokenizer_class = <class 'sqlglot.dialects.dialect.JSONPathTokenizer'>
parser_class = <class 'sqlglot.parsers.postgres.PostgresParser'>
generator_class = <class 'sqlglot.generators.postgres.PostgresGenerator'>
TIME_TRIE: dict = {'d': {0: True, 'd': {0: True, 'd': {0: True}}, 'a': {'y': {0: True}}, 'y': {0: True}}, 'D': {0: True, 'D': {0: True, 'D': {0: True}}}, 'F': {'M': {'D': {'D': {0: True, 'D': {0: True}}}, 'H': {'H': {'1': {'2': {0: True}}, '2': {'4': {0: True}}}}, 'M': {'I': {0: True}, 'M': {0: True}}, 'S': {'S': {0: True}}}}, 'H': {'H': {'1': {'2': {0: True}}, '2': {'4': {0: True}}}}, 'm': {'i': {0: True}, 'm': {0: True}}, 'M': {'I': {0: True}, 'M': {0: True}}, 'O': {'F': {0: True}}, 's': {'s': {0: True}}, 'S': {'S': {0: True}}, 'T': {'M': {'D': {'a': {'y': {0: True}}, 'y': {0: True}}, 'M': {'o': {'n': {0: True, 't': {'h': {0: True}}}}}}, 'Z': {0: True}}, 'U': {'S': {0: True}}, 'w': {'w': {0: True}}, 'W': {'W': {0: True}}, 'y': {'y': {0: True, 'y': {0: True, 'y': {0: True}}}}, 'Y': {'Y': {0: True, 'Y': {0: True, 'Y': {0: True}}}}}
FORMAT_TRIE: dict = {'d': {0: True, 'd': {0: True, 'd': {0: True}}, 'a': {'y': {0: True}}, 'y': {0: True}}, 'D': {0: True, 'D': {0: True, 'D': {0: True}}}, 'F': {'M': {'D': {'D': {0: True, 'D': {0: True}}}, 'H': {'H': {'1': {'2': {0: True}}, '2': {'4': {0: True}}}}, 'M': {'I': {0: True}, 'M': {0: True}}, 'S': {'S': {0: True}}}}, 'H': {'H': {'1': {'2': {0: True}}, '2': {'4': {0: True}}}}, 'm': {'i': {0: True}, 'm': {0: True}}, 'M': {'I': {0: True}, 'M': {0: True}}, 'O': {'F': {0: True}}, 's': {'s': {0: True}}, 'S': {'S': {0: True}}, 'T': {'M': {'D': {'a': {'y': {0: True}}, 'y': {0: True}}, 'M': {'o': {'n': {0: True, 't': {'h': {0: True}}}}}}, 'Z': {0: True}}, 'U': {'S': {0: True}}, 'w': {'w': {0: True}}, 'W': {'W': {0: True}}, 'y': {'y': {0: True, 'y': {0: True, 'y': {0: True}}}}, 'Y': {'Y': {0: True, 'Y': {0: True, 'Y': {0: True}}}}}
INVERSE_TIME_MAPPING: dict[str, str] = {'%u': 'D', '%d': 'DD', '%j': 'DDD', '%-d': 'FMDD', '%-j': 'FMDDD', '%-I': 'FMHH12', '%-H': 'FMHH24', '%-M': 'FMMI', '%-m': 'FMMM', '%-S': 'FMSS', '%I': 'HH12', '%H': 'HH24', '%M': 'MI', '%m': 'MM', '%z': 'OF', '%S': 'SS', '%A': 'TMDay', '%a': 'TMDy', '%b': 'TMMon', '%B': 'TMMonth', '%Aenlower': 'day', '%aenlower': 'dy', '%Z': 'TZ', '%f': 'US', '%U': 'WW', '%y': 'YY', '%Ythree': 'YYY', '%Y': 'YYYY', '%mstrict': 'MM', '%dstrict': 'DD', '%Hstrict': 'HH24', '%Istrict': 'HH12', '%Mstrict': 'MI', '%Sstrict': 'SS'}
INVERSE_TIME_TRIE: dict = {'%': {'u': {0: True}, 'd': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'j': {0: True}, '-': {'d': {0: True}, 'j': {0: True}, 'I': {0: True}, 'H': {0: True}, 'M': {0: True}, 'm': {0: True}, 'S': {0: True}}, 'I': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'H': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'M': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'm': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'z': {0: True}, 'S': {0: True, 's': {'t': {'r': {'i': {'c': {'t': {0: True}}}}}}}, 'A': {0: True, 'e': {'n': {'l': {'o': {'w': {'e': {'r': {0: True}}}}}}}}, 'a': {0: True, 'e': {'n': {'l': {'o': {'w': {'e': {'r': {0: True}}}}}}}}, 'b': {0: True}, 'B': {0: True}, 'Z': {0: True}, 'f': {0: True}, 'U': {0: True}, 'y': {0: True}, 'Y': {'t': {'h': {'r': {'e': {'e': {0: True}}}}}, 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] = {'\x08': '\\b', '\x0c': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t', '\x0b': '\\v', '\\': '\\\\', '\x00': '\\x00', '\x01': '\\x01', '\x02': '\\x02', '\x03': '\\x03', '\x04': '\\x04', '\x05': '\\x05', '\x06': '\\x06', '\x07': '\\x07', '\x0e': '\\x0e', '\x0f': '\\x0f', '\x10': '\\x10', '\x11': '\\x11', '\x12': '\\x12', '\x13': '\\x13', '\x14': '\\x14', '\x15': '\\x15', '\x16': '\\x16', '\x17': '\\x17', '\x18': '\\x18', '\x19': '\\x19', '\x1a': '\\x1a', '\x1b': '\\x1b', '\x1c': '\\x1c', '\x1d': '\\x1d', '\x1e': '\\x1e', '\x1f': '\\x1f', '\x7f': '\\x7f'}
QUOTE_START = "'"
QUOTE_END = "'"
IDENTIFIER_START = '"'
IDENTIFIER_END = '"'
VALID_INTERVAL_UNITS: set[str] = {'MINUTE', 'QUARTERS', 'H', 'MILLISECON', 'EPOCH_MICROSECONDS', 'CENTS', 'EPOCH_MILLISECONDS', 'DW_ISO', 'WEEKOFYEAR', 'WK', 'WEEK_ISO', 'QUARTER', 'NSEC', 'SECONDS', 'DOW', 'MINUTES', 'S', 'WEEK', 'CENT', 'EPOCH', 'QTRS', 'YRS', 'MILLISEC', 'Q', 'MICROSECOND', 'MONTHS', 'MILLISECONDS', 'DAYOFMONTH', 'CENTURY', 'HH', 'EPOCH_SECONDS', 'MSECONDS', 'MON', 'MI', 'NANOSEC', 'DAY OF YEAR', 'DAYS', 'DAYOFWEEK_ISO', 'MICROSECS', 'HRS', 'NANOSECS', 'DOW_ISO', 'YR', 'MS', 'USECOND', 'DY', 'NANOSECOND', 'YYY', 'MSECS', 'CENTURIES', 'QTR', 'D', 'DW', 'WEEKOFYEARISO', 'MSEC', 'DOY', 'DAY', 'WY', 'EPOCH_MILLISECOND', 'MONS', 'EPOCH_SECOND', 'M', 'YY', 'EPOCH_NANOSECONDS', 'MICROSECONDS', 'TIMEZONE_HOUR', 'DAYOFWEEK', 'YEAR', 'USECONDS', 'DECS', 'HOUR', 'MICROSEC', 'USECS', 'WEEKISO', 'MIL', 'MILS', 'EPOCH_NANOSECOND', 'Y', 'W', 'WEEKDAY_ISO', 'DECADES', 'MILLENNIUM', 'DD', 'SECS', 'US', 'DEC', 'HOURS', 'MM', 'DAYOFWEEKISO', 'YEARS', 'TZH', 'MILLISECS', 'MIN', 'NSECONDS', 'C', 'SEC', 'USEC', 'TZM', 'TIMEZONE_MINUTE', 'SECOND', 'DAYOFYEAR', 'WEEKOFYEAR_ISO', 'MILLISECOND', 'DAY OF WEEK', 'EPOCH_MICROSECOND', 'MINS', 'MONTH', 'WOY', 'YYYY', 'MILLENIA', 'NS', 'HR', 'DECADE', 'WEEKDAY', 'NSECOND', 'MSECOND'}
BIT_START: str | None = "b'"
BIT_END: str | None = "'"
HEX_START: str | None = "x'"
HEX_END: str | None = "'"
BYTE_START: str | None = "e'"
BYTE_END: str | None = "'"
UNICODE_START: str | None = "U&'"
UNICODE_END: str | None = "'"
class Postgres.Tokenizer(sqlglot.tokens.Tokenizer):
 75    class Tokenizer(tokens.Tokenizer):
 76        NUMERIC_ESCAPES = {
 77            "x": (16, 1, 2, 0xFF),
 78            "u": (16, 4, 4, 0xFFFF),
 79            "U": (16, 8, 8, 0x10FFFF),
 80            "0": (8, 1, 3, 0o777),
 81        }
 82        NUMERIC_ESCAPES_ARE_BYTES = True
 83        DROP_UNKNOWN_ESCAPES = True
 84        BIT_STRINGS = [("b'", "'"), ("B'", "'")]
 85        HEX_STRINGS = [("x'", "'"), ("X'", "'")]
 86        BYTE_STRINGS = [("e'", "'"), ("E'", "'")]
 87        UNICODE_STRINGS = [("U&'", "'"), ("u&'", "'")]
 88        BYTE_STRING_ESCAPES = ["'", "\\"]
 89        HEREDOC_STRINGS = ["$"]
 90
 91        HEREDOC_TAG_IS_IDENTIFIER = True
 92        HEREDOC_STRING_ALTERNATIVE = TokenType.PARAMETER
 93
 94        COMMANDS = {*tokens.Tokenizer.COMMANDS, TokenType.LOCK}
 95
 96        KEYWORDS = {
 97            **tokens.Tokenizer.KEYWORDS,
 98            "~": TokenType.RLIKE,
 99            "@@": TokenType.DAT,
100            "@?": TokenType.AT_QMARK,
101            "@>": TokenType.AT_GT,
102            "<@": TokenType.LT_AT,
103            "?&": TokenType.QMARK_AMP,
104            "?|": TokenType.QMARK_PIPE,
105            "#-": TokenType.HASH_DASH,
106            "|/": TokenType.PIPE_SLASH,
107            "||/": TokenType.DPIPE_SLASH,
108            "^@": TokenType.CARET_AT,
109            "BEGIN": TokenType.BEGIN,
110            "BIGSERIAL": TokenType.BIGSERIAL,
111            "CSTRING": TokenType.PSEUDO_TYPE,
112            "DECLARE": TokenType.COMMAND,
113            "DO": TokenType.COMMAND,
114            "EXEC": TokenType.COMMAND,
115            "HSTORE": TokenType.HSTORE,
116            "INT8": TokenType.BIGINT,
117            "MONEY": TokenType.MONEY,
118            "NAME": TokenType.NAME,
119            "OID": TokenType.OBJECT_IDENTIFIER,
120            "ONLY": TokenType.ONLY,
121            "POINT": TokenType.POINT,
122            "REFRESH": TokenType.COMMAND,
123            "REINDEX": TokenType.COMMAND,
124            "RESET": TokenType.COMMAND,
125            "SERIAL": TokenType.SERIAL,
126            "SMALLSERIAL": TokenType.SMALLSERIAL,
127            "TEMP": TokenType.TEMPORARY,
128            "TYPE": TokenType.TYPE,
129            "REGCLASS": TokenType.OBJECT_IDENTIFIER,
130            "REGCOLLATION": TokenType.OBJECT_IDENTIFIER,
131            "REGCONFIG": TokenType.OBJECT_IDENTIFIER,
132            "REGDICTIONARY": TokenType.OBJECT_IDENTIFIER,
133            "REGNAMESPACE": TokenType.OBJECT_IDENTIFIER,
134            "REGOPER": TokenType.OBJECT_IDENTIFIER,
135            "REGOPERATOR": TokenType.OBJECT_IDENTIFIER,
136            "REGPROC": TokenType.OBJECT_IDENTIFIER,
137            "REGPROCEDURE": TokenType.OBJECT_IDENTIFIER,
138            "REGROLE": TokenType.OBJECT_IDENTIFIER,
139            "REGTYPE": TokenType.OBJECT_IDENTIFIER,
140            "FLOAT": TokenType.DOUBLE,
141            "XML": TokenType.XML,
142            "VARIADIC": TokenType.VARIADIC,
143            "INOUT": TokenType.INOUT,
144        }
145        KEYWORDS.pop("/*+")
146        KEYWORDS.pop("DIV")
147
148        SINGLE_TOKENS = {
149            **tokens.Tokenizer.SINGLE_TOKENS,
150            "$": TokenType.HEREDOC_STRING,
151        }
152
153        VAR_SINGLE_TOKENS = {"$"}
NUMERIC_ESCAPES = {'x': (16, 1, 2, 255), 'u': (16, 4, 4, 65535), 'U': (16, 8, 8, 1114111), '0': (8, 1, 3, 511)}
NUMERIC_ESCAPES_ARE_BYTES = True
DROP_UNKNOWN_ESCAPES = True
BIT_STRINGS = [("b'", "'"), ("B'", "'")]
HEX_STRINGS = [("x'", "'"), ("X'", "'")]
BYTE_STRINGS = [("e'", "'"), ("E'", "'")]
UNICODE_STRINGS = [("U&'", "'"), ("u&'", "'")]
BYTE_STRING_ESCAPES = ["'", '\\']
HEREDOC_STRINGS = ['$']
HEREDOC_TAG_IS_IDENTIFIER = True
HEREDOC_STRING_ALTERNATIVE = <TokenType.PARAMETER: 58>
COMMANDS = {<TokenType.FETCH: 274>, <TokenType.LOCK: 323>, <TokenType.RENAME: 375>, <TokenType.SHOW: 395>, <TokenType.COMMAND: 238>, <TokenType.EXECUTE: 271>}
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: 371>, '||': <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: 288>, '~~': <TokenType.LIKE: 319>, '~~*': <TokenType.ILIKE: 296>, '~*': <TokenType.IRLIKE: 308>, '-|-': <TokenType.ADJACENT: 65>, 'ALL': <TokenType.ALL: 221>, 'AND': <TokenType.AND: 34>, 'ANTI': <TokenType.ANTI: 222>, 'ANY': <TokenType.ANY: 223>, 'ASC': <TokenType.ASC: 226>, 'AS': <TokenType.ALIAS: 219>, 'ASOF': <TokenType.ASOF: 227>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 229>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 229>, 'BEGIN': <TokenType.BEGIN: 230>, 'BETWEEN': <TokenType.BETWEEN: 231>, 'CACHE': <TokenType.CACHE: 233>, 'UNCACHE': <TokenType.UNCACHE: 415>, 'CASE': <TokenType.CASE: 234>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 236>, 'COLLATE': <TokenType.COLLATE: 237>, 'COLUMN': <TokenType.COLUMN: 81>, 'COMMIT': <TokenType.COMMIT: 240>, 'CONNECT BY': <TokenType.CONNECT_BY: 241>, 'CONSTRAINT': <TokenType.CONSTRAINT: 242>, 'COPY': <TokenType.COPY: 243>, 'CREATE': <TokenType.CREATE: 244>, 'CROSS': <TokenType.CROSS: 245>, 'CUBE': <TokenType.CUBE: 246>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 247>, 'CURRENT_SCHEMA': <TokenType.CURRENT_SCHEMA: 249>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 250>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 251>, 'CURRENT_USER': <TokenType.CURRENT_USER: 252>, 'CURRENT_CATALOG': <TokenType.CURRENT_CATALOG: 255>, 'DATABASE': <TokenType.DATABASE: 80>, 'DEFAULT': <TokenType.DEFAULT: 257>, 'DELETE': <TokenType.DELETE: 258>, 'DESC': <TokenType.DESC: 259>, 'DESCRIBE': <TokenType.DESCRIBE: 260>, 'DISTINCT': <TokenType.DISTINCT: 263>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 264>, 'DROP': <TokenType.DROP: 266>, 'ELSE': <TokenType.ELSE: 267>, 'END': <TokenType.END: 268>, 'ENUM': <TokenType.ENUM: 206>, 'ESCAPE': <TokenType.ESCAPE: 269>, 'EXCEPT': <TokenType.EXCEPT: 270>, 'EXECUTE': <TokenType.EXECUTE: 271>, 'EXISTS': <TokenType.EXISTS: 272>, 'FALSE': <TokenType.FALSE: 273>, 'FETCH': <TokenType.FETCH: 274>, 'FILTER': <TokenType.FILTER: 277>, 'FILE': <TokenType.FILE: 275>, 'FIRST': <TokenType.FIRST: 279>, 'FULL': <TokenType.FULL: 285>, 'FUNCTION': <TokenType.FUNCTION: 286>, 'FOR': <TokenType.FOR: 280>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 282>, 'FORMAT': <TokenType.FORMAT: 283>, 'FROM': <TokenType.FROM: 284>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 173>, 'GEOMETRY': <TokenType.GEOMETRY: 176>, 'GLOB': <TokenType.GLOB: 288>, 'GROUP BY': <TokenType.GROUP_BY: 291>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 292>, 'HAVING': <TokenType.HAVING: 293>, 'ILIKE': <TokenType.ILIKE: 296>, 'IN': <TokenType.IN: 297>, 'INDEX': <TokenType.INDEX: 298>, 'INET': <TokenType.INET: 201>, 'INNER': <TokenType.INNER: 300>, 'INSERT': <TokenType.INSERT: 301>, 'INTERVAL': <TokenType.INTERVAL: 305>, 'INTERSECT': <TokenType.INTERSECT: 304>, 'INTO': <TokenType.INTO: 306>, 'IS': <TokenType.IS: 309>, 'ISNULL': <TokenType.ISNULL: 310>, 'JOIN': <TokenType.JOIN: 311>, 'KEEP': <TokenType.KEEP: 313>, 'KILL': <TokenType.KILL: 315>, 'LATERAL': <TokenType.LATERAL: 317>, 'LEFT': <TokenType.LEFT: 318>, 'LIKE': <TokenType.LIKE: 319>, 'LIMIT': <TokenType.LIMIT: 320>, 'LOAD': <TokenType.LOAD: 322>, 'LOCALTIME': <TokenType.LOCALTIME: 180>, 'LOCALTIMESTAMP': <TokenType.LOCALTIMESTAMP: 181>, 'LOCK': <TokenType.LOCK: 323>, 'MERGE': <TokenType.MERGE: 329>, 'NAMESPACE': <TokenType.NAMESPACE: 441>, 'NATURAL': <TokenType.NATURAL: 332>, 'NEXT': <TokenType.NEXT: 333>, 'NOT': <TokenType.NOT: 27>, 'NOTNULL': <TokenType.NOTNULL: 335>, 'NULL': <TokenType.NULL: 336>, 'OBJECT': <TokenType.OBJECT: 200>, 'OFFSET': <TokenType.OFFSET: 338>, 'ON': <TokenType.ON: 339>, 'OR': <TokenType.OR: 35>, 'XOR': <TokenType.XOR: 66>, 'ORDER BY': <TokenType.ORDER_BY: 342>, 'ORDINALITY': <TokenType.ORDINALITY: 345>, 'OUT': <TokenType.OUT: 346>, 'OUTER': <TokenType.OUTER: 348>, 'OVER': <TokenType.OVER: 349>, 'OVERLAPS': <TokenType.OVERLAPS: 350>, 'OVERWRITE': <TokenType.OVERWRITE: 351>, 'PARTITION': <TokenType.PARTITION: 353>, 'PARTITION BY': <TokenType.PARTITION_BY: 354>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 354>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 354>, 'PERCENT': <TokenType.PERCENT: 355>, 'PIVOT': <TokenType.PIVOT: 356>, 'PRAGMA': <TokenType.PRAGMA: 361>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 363>, 'PROCEDURE': <TokenType.PROCEDURE: 364>, 'OPERATOR': <TokenType.OPERATOR: 341>, 'QUALIFY': <TokenType.QUALIFY: 369>, 'RANGE': <TokenType.RANGE: 372>, 'RECURSIVE': <TokenType.RECURSIVE: 373>, 'REGEXP': <TokenType.RLIKE: 381>, 'RENAME': <TokenType.RENAME: 375>, 'REPLACE': <TokenType.REPLACE: 376>, 'RETURNING': <TokenType.RETURNING: 377>, 'REFERENCES': <TokenType.REFERENCES: 379>, 'RIGHT': <TokenType.RIGHT: 380>, 'RLIKE': <TokenType.RLIKE: 381>, 'ROLLBACK': <TokenType.ROLLBACK: 383>, 'ROLLUP': <TokenType.ROLLUP: 384>, 'ROW': <TokenType.ROW: 385>, 'ROWS': <TokenType.ROWS: 386>, 'SCHEMA': <TokenType.SCHEMA: 83>, 'SELECT': <TokenType.SELECT: 388>, 'SEMI': <TokenType.SEMI: 389>, 'SESSION': <TokenType.SESSION: 59>, 'SESSION_USER': <TokenType.SESSION_USER: 61>, 'SET': <TokenType.SET: 393>, 'SETTINGS': <TokenType.SETTINGS: 394>, 'SHOW': <TokenType.SHOW: 395>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 396>, 'SOME': <TokenType.SOME: 397>, 'SORT BY': <TokenType.SORT_BY: 398>, 'SQL SECURITY': <TokenType.SQL_SECURITY: 400>, 'STRAIGHT_JOIN': <TokenType.STRAIGHT_JOIN: 403>, 'TABLE': <TokenType.TABLE: 84>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 406>, 'TEMP': <TokenType.TEMPORARY: 408>, 'TEMPORARY': <TokenType.TEMPORARY: 408>, 'THEN': <TokenType.THEN: 410>, 'TRUE': <TokenType.TRUE: 411>, 'TRUNCATE': <TokenType.TRUNCATE: 412>, 'TRIGGER': <TokenType.TRIGGER: 413>, 'UNION': <TokenType.UNION: 417>, 'UNKNOWN': <TokenType.UNKNOWN: 215>, 'UNNEST': <TokenType.UNNEST: 418>, 'UNPIVOT': <TokenType.UNPIVOT: 419>, 'UPDATE': <TokenType.UPDATE: 420>, 'USE': <TokenType.USE: 421>, 'USING': <TokenType.USING: 422>, 'UUID': <TokenType.UUID: 172>, 'VALUES': <TokenType.VALUES: 423>, 'VIEW': <TokenType.VIEW: 425>, 'VOLATILE': <TokenType.VOLATILE: 427>, 'WHEN': <TokenType.WHEN: 429>, 'WHERE': <TokenType.WHERE: 430>, 'WINDOW': <TokenType.WINDOW: 431>, 'WITH': <TokenType.WITH: 432>, 'APPLY': <TokenType.APPLY: 224>, 'ARRAY': <TokenType.ARRAY: 225>, '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.BIGINT: 108>, '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: 321>, 'MAP': <TokenType.MAP: 324>, 'NULLABLE': <TokenType.NULLABLE: 175>, 'NUMBER': <TokenType.DECIMAL: 118>, 'NUMERIC': <TokenType.DECIMAL: 118>, 'FIXED': <TokenType.DECIMAL: 118>, 'REAL': <TokenType.FLOAT: 115>, 'FLOAT': <TokenType.DOUBLE: 116>, '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: 433>, 'VECTOR': <TokenType.VECTOR: 216>, 'STRUCT': <TokenType.STRUCT: 404>, 'SEQUENCE': <TokenType.SEQUENCE: 391>, 'VARIANT': <TokenType.VARIANT: 199>, 'ALTER': <TokenType.ALTER: 220>, 'ANALYZE': <TokenType.ANALYZE: 440>, 'CALL': <TokenType.COMMAND: 238>, 'COMMENT': <TokenType.COMMENT: 239>, 'EXPLAIN': <TokenType.COMMAND: 238>, 'GRANT': <TokenType.GRANT: 290>, 'REVOKE': <TokenType.REVOKE: 378>, 'OPTIMIZE': <TokenType.COMMAND: 238>, 'PREPARE': <TokenType.COMMAND: 238>, 'VACUUM': <TokenType.COMMAND: 238>, 'USER-DEFINED': <TokenType.USERDEFINED: 194>, '~': <TokenType.RLIKE: 381>, '@@': <TokenType.DAT: 53>, '@?': <TokenType.AT_QMARK: 54>, '@>': <TokenType.AT_GT: 56>, '<@': <TokenType.LT_AT: 55>, '?&': <TokenType.QMARK_AMP: 68>, '?|': <TokenType.QMARK_PIPE: 69>, '#-': <TokenType.HASH_DASH: 70>, '|/': <TokenType.PIPE_SLASH: 40>, '||/': <TokenType.DPIPE_SLASH: 41>, '^@': <TokenType.CARET_AT: 43>, 'BIGSERIAL': <TokenType.BIGSERIAL: 191>, 'CSTRING': <TokenType.PSEUDO_TYPE: 367>, 'DECLARE': <TokenType.COMMAND: 238>, 'DO': <TokenType.COMMAND: 238>, 'EXEC': <TokenType.COMMAND: 238>, 'HSTORE': <TokenType.HSTORE: 187>, 'MONEY': <TokenType.MONEY: 195>, 'NAME': <TokenType.NAME: 139>, 'OID': <TokenType.OBJECT_IDENTIFIER: 337>, 'ONLY': <TokenType.ONLY: 340>, 'POINT': <TokenType.POINT: 177>, 'REFRESH': <TokenType.COMMAND: 238>, 'REINDEX': <TokenType.COMMAND: 238>, 'RESET': <TokenType.COMMAND: 238>, 'SERIAL': <TokenType.SERIAL: 189>, 'SMALLSERIAL': <TokenType.SMALLSERIAL: 190>, 'TYPE': <TokenType.TYPE: 414>, 'REGCLASS': <TokenType.OBJECT_IDENTIFIER: 337>, 'REGCOLLATION': <TokenType.OBJECT_IDENTIFIER: 337>, 'REGCONFIG': <TokenType.OBJECT_IDENTIFIER: 337>, 'REGDICTIONARY': <TokenType.OBJECT_IDENTIFIER: 337>, 'REGNAMESPACE': <TokenType.OBJECT_IDENTIFIER: 337>, 'REGOPER': <TokenType.OBJECT_IDENTIFIER: 337>, 'REGOPERATOR': <TokenType.OBJECT_IDENTIFIER: 337>, 'REGPROC': <TokenType.OBJECT_IDENTIFIER: 337>, 'REGPROCEDURE': <TokenType.OBJECT_IDENTIFIER: 337>, 'REGROLE': <TokenType.OBJECT_IDENTIFIER: 337>, 'REGTYPE': <TokenType.OBJECT_IDENTIFIER: 337>, 'XML': <TokenType.XML: 192>, 'VARIADIC': <TokenType.VARIADIC: 424>, 'INOUT': <TokenType.INOUT: 347>}
SINGLE_TOKENS = {'(': <TokenType.L_PAREN: 1>, ')': <TokenType.R_PAREN: 2>, '[': <TokenType.L_BRACKET: 3>, ']': <TokenType.R_BRACKET: 4>, '{': <TokenType.L_BRACE: 5>, '}': <TokenType.R_BRACE: 6>, '&': <TokenType.AMP: 36>, '^': <TokenType.CARET: 42>, ':': <TokenType.COLON: 11>, ',': <TokenType.COMMA: 7>, '.': <TokenType.DOT: 8>, '-': <TokenType.DASH: 9>, '=': <TokenType.EQ: 28>, '>': <TokenType.GT: 25>, '<': <TokenType.LT: 23>, '%': <TokenType.MOD: 330>, '!': <TokenType.NOT: 27>, '|': <TokenType.PIPE: 39>, '+': <TokenType.PLUS: 10>, ';': <TokenType.SEMICOLON: 19>, '/': <TokenType.SLASH: 22>, '\\': <TokenType.BACKSLASH: 21>, '*': <TokenType.STAR: 20>, '~': <TokenType.TILDE: 44>, '?': <TokenType.PLACEHOLDER: 357>, '@': <TokenType.PARAMETER: 58>, '#': <TokenType.HASH: 48>, "'": <TokenType.UNKNOWN: 215>, '`': <TokenType.UNKNOWN: 215>, '"': <TokenType.UNKNOWN: 215>, '$': <TokenType.HEREDOC_STRING: 96>}
VAR_SINGLE_TOKENS = {'$'}