Edit on GitHub

sqlglot.dialects.presto

 1from __future__ import annotations
 2
 3import typing as t
 4
 5from sqlglot import tokens
 6from sqlglot.dialects.dialect import (
 7    Dialect,
 8    NormalizationStrategy,
 9)
10from sqlglot.dialects.mysql import MySQL
11from sqlglot.generators.presto import PrestoGenerator
12from sqlglot.parsers.presto import PrestoParser
13from sqlglot.tokens import TokenType
14from sqlglot.typing.presto import EXPRESSION_METADATA
15
16
17class Presto(Dialect):
18    INDEX_OFFSET = 1
19    NULL_ORDERING = "nulls_are_last"
20    TIME_FORMAT = MySQL.TIME_FORMAT
21    STRICT_STRING_CONCAT = True
22    TYPED_DIVISION = True
23    TABLESAMPLE_SIZE_IS_PERCENT = True
24    LOG_BASE_FIRST: bool | None = None
25    SUPPORTS_LIMIT_ALL = True
26    SUPPORTS_VALUES_DEFAULT = False
27    LEAST_GREATEST_IGNORES_NULLS = False
28    UUID_IS_STRING_TYPE = False
29
30    TIME_MAPPING = MySQL.TIME_MAPPING
31
32    # https://github.com/trinodb/trino/issues/17
33    # https://github.com/trinodb/trino/issues/12289
34    # https://github.com/prestodb/presto/issues/2863
35    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
36
37    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
38
39    SUPPORTED_SETTINGS = {
40        *Dialect.SUPPORTED_SETTINGS,
41        "variant_extract_is_json_extract",
42    }
43
44    class Tokenizer(tokens.Tokenizer):
45        HEX_STRINGS = [("x'", "'"), ("X'", "'")]
46        UNICODE_STRINGS = [
47            (prefix + q, q)
48            for q in t.cast(list[str], tokens.Tokenizer.QUOTES)
49            for prefix in ("U&", "u&")
50        ]
51
52        NESTED_COMMENTS = False
53
54        KEYWORDS = {
55            **tokens.Tokenizer.KEYWORDS,
56            "DEALLOCATE PREPARE": TokenType.COMMAND,
57            "DESCRIBE INPUT": TokenType.COMMAND,
58            "DESCRIBE OUTPUT": TokenType.COMMAND,
59            "RESET SESSION": TokenType.COMMAND,
60            "START": TokenType.BEGIN,
61            "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
62            "ROW": TokenType.STRUCT,
63            "IPADDRESS": TokenType.IPADDRESS,
64            "IPPREFIX": TokenType.IPPREFIX,
65            "TDIGEST": TokenType.TDIGEST,
66            "HYPERLOGLOG": TokenType.HLLSKETCH,
67        }
68        KEYWORDS.pop("/*+")
69        KEYWORDS.pop("QUALIFY")
70
71    Parser = PrestoParser
72
73    Generator = PrestoGenerator
class Presto(sqlglot.dialects.dialect.Dialect):
18class Presto(Dialect):
19    INDEX_OFFSET = 1
20    NULL_ORDERING = "nulls_are_last"
21    TIME_FORMAT = MySQL.TIME_FORMAT
22    STRICT_STRING_CONCAT = True
23    TYPED_DIVISION = True
24    TABLESAMPLE_SIZE_IS_PERCENT = True
25    LOG_BASE_FIRST: bool | None = None
26    SUPPORTS_LIMIT_ALL = True
27    SUPPORTS_VALUES_DEFAULT = False
28    LEAST_GREATEST_IGNORES_NULLS = False
29    UUID_IS_STRING_TYPE = False
30
31    TIME_MAPPING = MySQL.TIME_MAPPING
32
33    # https://github.com/trinodb/trino/issues/17
34    # https://github.com/trinodb/trino/issues/12289
35    # https://github.com/prestodb/presto/issues/2863
36    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
37
38    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
39
40    SUPPORTED_SETTINGS = {
41        *Dialect.SUPPORTED_SETTINGS,
42        "variant_extract_is_json_extract",
43    }
44
45    class Tokenizer(tokens.Tokenizer):
46        HEX_STRINGS = [("x'", "'"), ("X'", "'")]
47        UNICODE_STRINGS = [
48            (prefix + q, q)
49            for q in t.cast(list[str], tokens.Tokenizer.QUOTES)
50            for prefix in ("U&", "u&")
51        ]
52
53        NESTED_COMMENTS = False
54
55        KEYWORDS = {
56            **tokens.Tokenizer.KEYWORDS,
57            "DEALLOCATE PREPARE": TokenType.COMMAND,
58            "DESCRIBE INPUT": TokenType.COMMAND,
59            "DESCRIBE OUTPUT": TokenType.COMMAND,
60            "RESET SESSION": TokenType.COMMAND,
61            "START": TokenType.BEGIN,
62            "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
63            "ROW": TokenType.STRUCT,
64            "IPADDRESS": TokenType.IPADDRESS,
65            "IPPREFIX": TokenType.IPPREFIX,
66            "TDIGEST": TokenType.TDIGEST,
67            "HYPERLOGLOG": TokenType.HLLSKETCH,
68        }
69        KEYWORDS.pop("/*+")
70        KEYWORDS.pop("QUALIFY")
71
72    Parser = PrestoParser
73
74    Generator = PrestoGenerator
INDEX_OFFSET = 1

The base index offset for arrays.

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"

TIME_FORMAT = "'%Y-%m-%d %T'"
STRICT_STRING_CONCAT = True

Whether CONCAT's arguments must be strings.

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.

TABLESAMPLE_SIZE_IS_PERCENT = True

Whether a size in the table sample clause represents percentage.

LOG_BASE_FIRST: bool | None = None

Whether the base comes first in the LOG function. Possible values: True, False, None (two arguments are not supported by LOG)

SUPPORTS_LIMIT_ALL = True

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

SUPPORTS_VALUES_DEFAULT = False

Whether the DEFAULT keyword is supported in the VALUES clause.

LEAST_GREATEST_IGNORES_NULLS = False

Whether LEAST/GREATEST functions ignore NULL values, e.g:

  • BigQuery, Snowflake, MySQL, Presto/Trino: LEAST(1, NULL, 2) -> NULL
  • Spark, Postgres, DuckDB, TSQL: LEAST(1, NULL, 2) -> 1
UUID_IS_STRING_TYPE = False

Whether a UUID is considered a string or a UUID type.

TIME_MAPPING = {'%M': '%B', '%c': '%-m', '%e': '%-d', '%h': '%I', '%i': '%M', '%s': '%S', '%u': '%W', '%k': '%-H', '%l': '%-I', '%T': '%H:%M:%S', '%W': '%A'}

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

NORMALIZATION_STRATEGY = <NormalizationStrategy.CASE_INSENSITIVE: 'CASE_INSENSITIVE'>

Specifies the strategy according to which identifiers should be normalized.

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.ArrayContains'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <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'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.core.BitwiseLeftShift'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseOr'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.core.BitwiseRightShift'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseXor'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <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.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.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 <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'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <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'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <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.Ntile'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.aggregate.CountIf'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.aggregate.Rank'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.functions.Int64'>: {'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.RowNumber'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.aggregate.DenseRank'>: {'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.core.ApproxDistinct'>: {'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.EndsWith'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.aggregate.LogicalAnd'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.Boolean'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.Between'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.string.Contains'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.Any'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.math.IsInf'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.math.IsNan'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.All'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.functions.Exists'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.string.StartsWith'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.In'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.aggregate.LogicalOr'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.temporal.TsOrDsToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.TimeStrToDate'>: {'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.StrToDate'>: {'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.DiToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.CurrentDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.CurrentDatetime'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.temporal.DatetimeSub'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.temporal.DatetimeAdd'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.temporal.Datetime'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.math.Acos'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Pi'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Cot'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Ln'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Cos'>: {'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.Sin'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.StddevSamp'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.ApproxQuantile'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Tanh'>: {'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.Atanh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Degrees'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.PercentRank'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.functions.Rand'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.math.Asinh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.PercentileCont'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.CumeDist'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Sqrt'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Acosh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.CovarPop'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.string.ToDouble'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Round'>: {'annotator': <function <dictcomp>.<lambda>>}, <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.aggregate.Avg'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Cosh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Sinh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.VariancePop'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.StddevPop'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Quantile'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Radians'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.SafeDivide'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Skewness'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Atan'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Asin'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.CovarSamp'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.temporal.TsOrDiToDi'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.TimeDiff'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.math.Ceil'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.temporal.TimestampDiff'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.math.Getbit'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DatetimeDiff'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DayOfMonth'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.Length'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.temporal.DateToDi'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.BitLength'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.Quarter'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.StrPosition'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.string.Unicode'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.Hour'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.Ascii'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.UnixDate'>: {'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.string.Levenshtein'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.math.Sign'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.temporal.MakeInterval'>: {'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.datatypes.Interval'>: {'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.TimeSub'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.TimeAdd'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.CurrentTime'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.Time'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.Localtime'>: {'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.TimestampSub'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.StrToTime'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.UnixToTime'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.TimestampAdd'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.CurrentTimestamp'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.TimeStrToTime'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.Week'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.Year'>: {'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.YearOfWeek'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.Month'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.Day'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.WeekOfYear'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.DateToDateStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentSchema'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.MD5'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.TimeToTimeStr'>: {'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.Upper'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Trim'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.array.ArrayToString'>: {'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.Concat'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Lower'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Chr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.UnixToStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.String'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.TimeToStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.ToBase32'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Space'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Initcap'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Translate'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.SessionUser'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.UnixToTimeStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.ConcatWs'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentVersion'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Substring'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentCatalog'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.TsOrDsToDateStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.query.RawString'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentUser'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.SHA2'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.SHA'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.array.ArraySlice'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayReverse'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.AnyValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.query.Limit'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Filter'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.query.Window'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.FirstValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.HavingMax'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.LastValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.math.Abs'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.query.Order'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.SortArray'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.ArrayConcatAgg'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.NthValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Greatest'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Coalesce'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.Min'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.Max'>: {'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.array.ArrayLast'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayFirst'>: {'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.DateAdd'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.temporal.DateSub'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.TryCast'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Cast'>: {'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.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.math.Floor'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.string.MD5Digest'>: {'returns': <DType.VARBINARY: 'VARBINARY'>}}
SUPPORTED_SETTINGS = {'variant_extract_is_json_extract', 'normalization_strategy', '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 = False

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

INITCAP_SUPPORTS_CUSTOM_DELIMITERS = False
tokenizer_class = <class 'Presto.Tokenizer'>
jsonpath_tokenizer_class = <class 'sqlglot.dialects.dialect.JSONPathTokenizer'>
parser_class = <class 'sqlglot.parsers.presto.PrestoParser'>
generator_class = <class 'sqlglot.generators.presto.PrestoGenerator'>
TIME_TRIE: dict = {'%': {'M': {0: True}, 'c': {0: True}, 'e': {0: True}, 'h': {0: True}, 'i': {0: True}, 's': {0: True}, 'u': {0: True}, 'k': {0: True}, 'l': {0: True}, 'T': {0: True}, 'W': {0: True}}}
FORMAT_TRIE: dict = {'%': {'M': {0: True}, 'c': {0: True}, 'e': {0: True}, 'h': {0: True}, 'i': {0: True}, 's': {0: True}, 'u': {0: True}, 'k': {0: True}, 'l': {0: True}, 'T': {0: True}, 'W': {0: True}}}
INVERSE_TIME_MAPPING: dict[str, str] = {'%B': '%M', '%-m': '%c', '%-d': '%e', '%I': '%h', '%M': '%i', '%S': '%s', '%W': '%u', '%-H': '%k', '%-I': '%l', '%H:%M:%S': '%T', '%A': '%W'}
INVERSE_TIME_TRIE: dict = {'%': {'B': {0: True}, '-': {'m': {0: True}, 'd': {0: True}, 'H': {0: True}, 'I': {0: True}}, 'I': {0: True}, 'M': {0: True}, 'S': {0: True}, 'W': {0: True}, 'H': {':': {'%': {'M': {':': {'%': {'S': {0: True}}}}}}}, 'A': {0: True}}}
INVERSE_FORMAT_MAPPING: dict[str, str] = {}
INVERSE_FORMAT_TRIE: dict = {}
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] = {'HOURS', 'DOW', 'Q', 'MILLISECS', 'S', 'MILLISECON', 'DOW_ISO', 'QUARTERS', 'MIN', 'EPOCH_MICROSECONDS', 'EPOCH_MILLISECOND', 'TZH', 'WEEKOFYEAR_ISO', 'MILLISECONDS', 'CENTURY', 'US', 'MICROSECONDS', 'YEARS', 'USECONDS', 'DW_ISO', 'CENTS', 'DOY', 'HRS', 'QTRS', 'DECADES', 'USECS', 'W', 'DAY', 'DAYOFWEEK', 'HH', 'QUARTER', 'QTR', 'WEEKDAY_ISO', 'NS', 'YYYY', 'MSECS', 'C', 'USEC', 'NANOSEC', 'HR', 'EPOCH_NANOSECOND', 'YYY', 'WOY', 'TZM', 'DAY OF WEEK', 'MICROSEC', 'TIMEZONE_HOUR', 'DY', 'MINUTES', 'EPOCH', 'DAYOFMONTH', 'MIL', 'MONTHS', 'MILLENNIUM', 'YRS', 'MILS', 'DECADE', 'MM', 'MINUTE', 'MSECONDS', 'NSECONDS', 'MINS', 'MONTH', 'MSEC', 'MILLISEC', 'WEEKDAY', 'DEC', 'DD', 'MICROSECS', 'SECOND', 'WEEKISO', 'CENT', 'M', 'YR', 'DECS', 'WEEK_ISO', 'NSECOND', 'MILLENIA', 'D', 'DW', 'EPOCH_NANOSECONDS', 'HOUR', 'DAY OF YEAR', 'H', 'CENTURIES', 'MILLISECOND', 'DAYOFWEEKISO', 'WEEKOFYEARISO', 'EPOCH_MILLISECONDS', 'MS', 'EPOCH_SECONDS', 'EPOCH_MICROSECOND', 'NANOSECS', 'DAYS', 'WEEKOFYEAR', 'WY', 'YEAR', 'MI', 'SECONDS', 'YY', 'NANOSECOND', 'NSEC', 'USECOND', 'MON', 'EPOCH_SECOND', 'SEC', 'MSECOND', 'Y', 'MICROSECOND', 'DAYOFYEAR', 'SECS', 'WEEK', 'DAYOFWEEK_ISO', 'TIMEZONE_MINUTE', 'WK', 'MONS'}
BIT_START: str | None = None
BIT_END: str | None = None
HEX_START: str | None = "x'"
HEX_END: str | None = "'"
BYTE_START: str | None = None
BYTE_END: str | None = None
UNICODE_START: str | None = "U&'"
UNICODE_END: str | None = "'"
class Presto.Tokenizer(sqlglot.tokens.Tokenizer):
45    class Tokenizer(tokens.Tokenizer):
46        HEX_STRINGS = [("x'", "'"), ("X'", "'")]
47        UNICODE_STRINGS = [
48            (prefix + q, q)
49            for q in t.cast(list[str], tokens.Tokenizer.QUOTES)
50            for prefix in ("U&", "u&")
51        ]
52
53        NESTED_COMMENTS = False
54
55        KEYWORDS = {
56            **tokens.Tokenizer.KEYWORDS,
57            "DEALLOCATE PREPARE": TokenType.COMMAND,
58            "DESCRIBE INPUT": TokenType.COMMAND,
59            "DESCRIBE OUTPUT": TokenType.COMMAND,
60            "RESET SESSION": TokenType.COMMAND,
61            "START": TokenType.BEGIN,
62            "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
63            "ROW": TokenType.STRUCT,
64            "IPADDRESS": TokenType.IPADDRESS,
65            "IPPREFIX": TokenType.IPPREFIX,
66            "TDIGEST": TokenType.TDIGEST,
67            "HYPERLOGLOG": TokenType.HLLSKETCH,
68        }
69        KEYWORDS.pop("/*+")
70        KEYWORDS.pop("QUALIFY")
HEX_STRINGS = [("x'", "'"), ("X'", "'")]
UNICODE_STRINGS = [("U&'", "'"), ("u&'", "'")]
NESTED_COMMENTS = False
KEYWORDS = {'{%': <TokenType.BLOCK_START: 72>, '{%+': <TokenType.BLOCK_START: 72>, '{%-': <TokenType.BLOCK_START: 72>, '%}': <TokenType.BLOCK_END: 73>, '+%}': <TokenType.BLOCK_END: 73>, '-%}': <TokenType.BLOCK_END: 73>, '{{+': <TokenType.BLOCK_START: 72>, '{{-': <TokenType.BLOCK_START: 72>, '+}}': <TokenType.BLOCK_END: 73>, '-}}': <TokenType.BLOCK_END: 73>, '&<': <TokenType.AMP_LT: 62>, '&>': <TokenType.AMP_GT: 63>, '==': <TokenType.EQ: 28>, '::': <TokenType.DCOLON: 14>, '?::': <TokenType.QDCOLON: 368>, '||': <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: 61>, '??': <TokenType.DQMARK: 18>, '~~~': <TokenType.GLOB: 286>, '~~': <TokenType.LIKE: 317>, '~~*': <TokenType.ILIKE: 294>, '~*': <TokenType.IRLIKE: 306>, '-|-': <TokenType.ADJACENT: 64>, 'ALL': <TokenType.ALL: 219>, 'AND': <TokenType.AND: 34>, 'ANTI': <TokenType.ANTI: 220>, 'ANY': <TokenType.ANY: 221>, 'ASC': <TokenType.ASC: 224>, 'AS': <TokenType.ALIAS: 217>, 'ASOF': <TokenType.ASOF: 225>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 227>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 227>, 'BEGIN': <TokenType.BEGIN: 228>, 'BETWEEN': <TokenType.BETWEEN: 229>, 'CACHE': <TokenType.CACHE: 231>, 'UNCACHE': <TokenType.UNCACHE: 412>, 'CASE': <TokenType.CASE: 232>, 'CHARACTER SET': <TokenType.CHARACTER_SET: 233>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 234>, 'COLLATE': <TokenType.COLLATE: 235>, 'COLUMN': <TokenType.COLUMN: 80>, 'COMMIT': <TokenType.COMMIT: 238>, 'CONNECT BY': <TokenType.CONNECT_BY: 239>, 'CONSTRAINT': <TokenType.CONSTRAINT: 240>, 'COPY': <TokenType.COPY: 241>, 'CREATE': <TokenType.CREATE: 242>, 'CROSS': <TokenType.CROSS: 243>, 'CUBE': <TokenType.CUBE: 244>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 245>, 'CURRENT_SCHEMA': <TokenType.CURRENT_SCHEMA: 247>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 248>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 249>, 'CURRENT_USER': <TokenType.CURRENT_USER: 250>, 'CURRENT_CATALOG': <TokenType.CURRENT_CATALOG: 253>, 'DATABASE': <TokenType.DATABASE: 79>, 'DEFAULT': <TokenType.DEFAULT: 255>, 'DELETE': <TokenType.DELETE: 256>, 'DESC': <TokenType.DESC: 257>, 'DESCRIBE': <TokenType.DESCRIBE: 258>, 'DISTINCT': <TokenType.DISTINCT: 261>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 262>, 'DIV': <TokenType.DIV: 263>, 'DROP': <TokenType.DROP: 264>, 'ELSE': <TokenType.ELSE: 265>, 'END': <TokenType.END: 266>, 'ENUM': <TokenType.ENUM: 204>, 'ESCAPE': <TokenType.ESCAPE: 267>, 'EXCEPT': <TokenType.EXCEPT: 268>, 'EXECUTE': <TokenType.EXECUTE: 269>, 'EXISTS': <TokenType.EXISTS: 270>, 'FALSE': <TokenType.FALSE: 271>, 'FETCH': <TokenType.FETCH: 272>, 'FILTER': <TokenType.FILTER: 275>, 'FILE': <TokenType.FILE: 273>, 'FIRST': <TokenType.FIRST: 277>, 'FULL': <TokenType.FULL: 283>, 'FUNCTION': <TokenType.FUNCTION: 284>, 'FOR': <TokenType.FOR: 278>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 280>, 'FORMAT': <TokenType.FORMAT: 281>, 'FROM': <TokenType.FROM: 282>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 171>, 'GEOMETRY': <TokenType.GEOMETRY: 174>, 'GLOB': <TokenType.GLOB: 286>, 'GROUP BY': <TokenType.GROUP_BY: 289>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 290>, 'HAVING': <TokenType.HAVING: 291>, 'ILIKE': <TokenType.ILIKE: 294>, 'IN': <TokenType.IN: 295>, 'INDEX': <TokenType.INDEX: 296>, 'INET': <TokenType.INET: 199>, 'INNER': <TokenType.INNER: 298>, 'INSERT': <TokenType.INSERT: 299>, 'INTERVAL': <TokenType.INTERVAL: 303>, 'INTERSECT': <TokenType.INTERSECT: 302>, 'INTO': <TokenType.INTO: 304>, 'IS': <TokenType.IS: 307>, 'ISNULL': <TokenType.ISNULL: 308>, 'JOIN': <TokenType.JOIN: 309>, 'KEEP': <TokenType.KEEP: 311>, 'KILL': <TokenType.KILL: 313>, 'LATERAL': <TokenType.LATERAL: 315>, 'LEFT': <TokenType.LEFT: 316>, 'LIKE': <TokenType.LIKE: 317>, 'LIMIT': <TokenType.LIMIT: 318>, 'LOAD': <TokenType.LOAD: 320>, 'LOCALTIME': <TokenType.LOCALTIME: 178>, 'LOCALTIMESTAMP': <TokenType.LOCALTIMESTAMP: 179>, 'LOCK': <TokenType.LOCK: 321>, 'MERGE': <TokenType.MERGE: 327>, 'NAMESPACE': <TokenType.NAMESPACE: 439>, 'NATURAL': <TokenType.NATURAL: 330>, 'NEXT': <TokenType.NEXT: 331>, 'NOT': <TokenType.NOT: 27>, 'NOTNULL': <TokenType.NOTNULL: 333>, 'NULL': <TokenType.NULL: 334>, 'OBJECT': <TokenType.OBJECT: 198>, 'OFFSET': <TokenType.OFFSET: 336>, 'ON': <TokenType.ON: 337>, 'OR': <TokenType.OR: 35>, 'XOR': <TokenType.XOR: 65>, 'ORDER BY': <TokenType.ORDER_BY: 340>, 'ORDINALITY': <TokenType.ORDINALITY: 343>, 'OUT': <TokenType.OUT: 344>, 'OUTER': <TokenType.OUTER: 346>, 'OVER': <TokenType.OVER: 347>, 'OVERLAPS': <TokenType.OVERLAPS: 348>, 'OVERWRITE': <TokenType.OVERWRITE: 349>, 'PARTITION': <TokenType.PARTITION: 351>, 'PARTITION BY': <TokenType.PARTITION_BY: 352>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 352>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 352>, 'PERCENT': <TokenType.PERCENT: 353>, 'PIVOT': <TokenType.PIVOT: 354>, 'PRAGMA': <TokenType.PRAGMA: 359>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 361>, 'PROCEDURE': <TokenType.PROCEDURE: 362>, 'OPERATOR': <TokenType.OPERATOR: 339>, 'RANGE': <TokenType.RANGE: 369>, 'RECURSIVE': <TokenType.RECURSIVE: 370>, 'REGEXP': <TokenType.RLIKE: 378>, 'RENAME': <TokenType.RENAME: 372>, 'REPLACE': <TokenType.REPLACE: 373>, 'RETURNING': <TokenType.RETURNING: 374>, 'REFERENCES': <TokenType.REFERENCES: 376>, 'RIGHT': <TokenType.RIGHT: 377>, 'RLIKE': <TokenType.RLIKE: 378>, 'ROLLBACK': <TokenType.ROLLBACK: 380>, 'ROLLUP': <TokenType.ROLLUP: 381>, 'ROW': <TokenType.STRUCT: 401>, 'ROWS': <TokenType.ROWS: 383>, 'SCHEMA': <TokenType.SCHEMA: 82>, 'SELECT': <TokenType.SELECT: 385>, 'SEMI': <TokenType.SEMI: 386>, 'SESSION': <TokenType.SESSION: 58>, 'SESSION_USER': <TokenType.SESSION_USER: 60>, 'SET': <TokenType.SET: 390>, 'SETTINGS': <TokenType.SETTINGS: 391>, 'SHOW': <TokenType.SHOW: 392>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 393>, 'SOME': <TokenType.SOME: 394>, 'SORT BY': <TokenType.SORT_BY: 395>, 'SQL SECURITY': <TokenType.SQL_SECURITY: 397>, 'START WITH': <TokenType.START_WITH: 398>, 'STRAIGHT_JOIN': <TokenType.STRAIGHT_JOIN: 400>, 'TABLE': <TokenType.TABLE: 83>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 403>, 'TEMP': <TokenType.TEMPORARY: 405>, 'TEMPORARY': <TokenType.TEMPORARY: 405>, 'THEN': <TokenType.THEN: 407>, 'TRUE': <TokenType.TRUE: 408>, 'TRUNCATE': <TokenType.TRUNCATE: 409>, 'TRIGGER': <TokenType.TRIGGER: 410>, 'UNION': <TokenType.UNION: 413>, 'UNKNOWN': <TokenType.UNKNOWN: 213>, 'UNNEST': <TokenType.UNNEST: 414>, 'UNPIVOT': <TokenType.UNPIVOT: 415>, 'UPDATE': <TokenType.UPDATE: 416>, 'USE': <TokenType.USE: 417>, 'USING': <TokenType.USING: 418>, 'UUID': <TokenType.UUID: 170>, 'VALUES': <TokenType.VALUES: 419>, 'VIEW': <TokenType.VIEW: 421>, 'VOLATILE': <TokenType.VOLATILE: 423>, 'WHEN': <TokenType.WHEN: 425>, 'WHERE': <TokenType.WHERE: 426>, 'WINDOW': <TokenType.WINDOW: 427>, 'WITH': <TokenType.WITH: 428>, 'APPLY': <TokenType.APPLY: 222>, 'ARRAY': <TokenType.ARRAY: 223>, 'BIT': <TokenType.BIT: 96>, 'BOOL': <TokenType.BOOLEAN: 97>, 'BOOLEAN': <TokenType.BOOLEAN: 97>, 'BYTE': <TokenType.TINYINT: 98>, 'MEDIUMINT': <TokenType.MEDIUMINT: 102>, 'INT1': <TokenType.TINYINT: 98>, 'TINYINT': <TokenType.TINYINT: 98>, 'INT16': <TokenType.SMALLINT: 100>, 'SHORT': <TokenType.SMALLINT: 100>, 'SMALLINT': <TokenType.SMALLINT: 100>, 'HUGEINT': <TokenType.INT128: 109>, 'UHUGEINT': <TokenType.UINT128: 110>, 'INT2': <TokenType.SMALLINT: 100>, 'INTEGER': <TokenType.INT: 104>, 'INT': <TokenType.INT: 104>, 'INT4': <TokenType.INT: 104>, 'INT32': <TokenType.INT: 104>, 'INT64': <TokenType.BIGINT: 106>, 'INT128': <TokenType.INT128: 109>, 'INT256': <TokenType.INT256: 111>, 'LONG': <TokenType.BIGINT: 106>, 'BIGINT': <TokenType.BIGINT: 106>, 'INT8': <TokenType.TINYINT: 98>, 'UINT': <TokenType.UINT: 105>, 'UINT128': <TokenType.UINT128: 110>, 'UINT256': <TokenType.UINT256: 112>, 'DEC': <TokenType.DECIMAL: 116>, 'DECIMAL': <TokenType.DECIMAL: 116>, 'DECIMAL32': <TokenType.DECIMAL32: 117>, 'DECIMAL64': <TokenType.DECIMAL64: 118>, 'DECIMAL128': <TokenType.DECIMAL128: 119>, 'DECIMAL256': <TokenType.DECIMAL256: 120>, 'DECFLOAT': <TokenType.DECFLOAT: 121>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 123>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 123>, 'BIGNUM': <TokenType.BIGNUM: 108>, 'LIST': <TokenType.LIST: 319>, 'MAP': <TokenType.MAP: 322>, 'NULLABLE': <TokenType.NULLABLE: 173>, 'NUMBER': <TokenType.DECIMAL: 116>, 'NUMERIC': <TokenType.DECIMAL: 116>, 'FIXED': <TokenType.DECIMAL: 116>, 'REAL': <TokenType.FLOAT: 113>, 'FLOAT': <TokenType.FLOAT: 113>, 'FLOAT4': <TokenType.FLOAT: 113>, 'FLOAT8': <TokenType.DOUBLE: 114>, 'DOUBLE': <TokenType.DOUBLE: 114>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 114>, 'JSON': <TokenType.JSON: 140>, 'JSONB': <TokenType.JSONB: 141>, 'CHAR': <TokenType.CHAR: 124>, 'CHARACTER': <TokenType.CHAR: 124>, 'CHAR VARYING': <TokenType.VARCHAR: 126>, 'CHARACTER VARYING': <TokenType.VARCHAR: 126>, 'NCHAR': <TokenType.NCHAR: 125>, 'VARCHAR': <TokenType.VARCHAR: 126>, 'VARCHAR2': <TokenType.VARCHAR: 126>, 'NVARCHAR': <TokenType.NVARCHAR: 127>, 'NVARCHAR2': <TokenType.NVARCHAR: 127>, 'BPCHAR': <TokenType.BPCHAR: 128>, 'STR': <TokenType.TEXT: 129>, 'STRING': <TokenType.TEXT: 129>, 'TEXT': <TokenType.TEXT: 129>, 'LONGTEXT': <TokenType.LONGTEXT: 131>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 130>, 'TINYTEXT': <TokenType.TINYTEXT: 136>, 'CLOB': <TokenType.TEXT: 129>, 'LONGVARCHAR': <TokenType.TEXT: 129>, 'BINARY': <TokenType.BINARY: 138>, 'BLOB': <TokenType.VARBINARY: 139>, 'LONGBLOB': <TokenType.LONGBLOB: 134>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 133>, 'TINYBLOB': <TokenType.TINYBLOB: 135>, 'BYTEA': <TokenType.VARBINARY: 139>, 'VARBINARY': <TokenType.VARBINARY: 139>, 'TIME': <TokenType.TIME: 142>, 'TIMETZ': <TokenType.TIMETZ: 143>, 'TIME_NS': <TokenType.TIME_NS: 144>, 'TIMESTAMP': <TokenType.TIMESTAMP: 145>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 146>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 147>, 'TIMESTAMP_LTZ': <TokenType.TIMESTAMPLTZ: 147>, 'TIMESTAMPNTZ': <TokenType.TIMESTAMPNTZ: 148>, 'TIMESTAMP_NTZ': <TokenType.TIMESTAMPNTZ: 148>, 'DATE': <TokenType.DATE: 156>, 'DATETIME': <TokenType.DATETIME: 152>, 'INT4RANGE': <TokenType.INT4RANGE: 158>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 159>, 'INT8RANGE': <TokenType.INT8RANGE: 160>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 161>, 'NUMRANGE': <TokenType.NUMRANGE: 162>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 163>, 'TSRANGE': <TokenType.TSRANGE: 164>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 165>, 'TSTZRANGE': <TokenType.TSTZRANGE: 166>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 167>, 'DATERANGE': <TokenType.DATERANGE: 168>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 169>, 'UNIQUE': <TokenType.UNIQUE: 429>, 'VECTOR': <TokenType.VECTOR: 214>, 'STRUCT': <TokenType.STRUCT: 401>, 'SEQUENCE': <TokenType.SEQUENCE: 388>, 'VARIANT': <TokenType.VARIANT: 197>, 'ALTER': <TokenType.ALTER: 218>, 'ANALYZE': <TokenType.ANALYZE: 438>, 'CALL': <TokenType.COMMAND: 236>, 'COMMENT': <TokenType.COMMENT: 237>, 'EXPLAIN': <TokenType.COMMAND: 236>, 'GRANT': <TokenType.GRANT: 288>, 'REVOKE': <TokenType.REVOKE: 375>, 'OPTIMIZE': <TokenType.COMMAND: 236>, 'PREPARE': <TokenType.COMMAND: 236>, 'VACUUM': <TokenType.COMMAND: 236>, 'USER-DEFINED': <TokenType.USERDEFINED: 192>, 'FOR VERSION': <TokenType.VERSION_SNAPSHOT: 433>, 'FOR TIMESTAMP': <TokenType.TIMESTAMP_SNAPSHOT: 434>, 'DEALLOCATE PREPARE': <TokenType.COMMAND: 236>, 'DESCRIBE INPUT': <TokenType.COMMAND: 236>, 'DESCRIBE OUTPUT': <TokenType.COMMAND: 236>, 'RESET SESSION': <TokenType.COMMAND: 236>, 'START': <TokenType.BEGIN: 228>, 'MATCH_RECOGNIZE': <TokenType.MATCH_RECOGNIZE: 325>, 'IPADDRESS': <TokenType.IPADDRESS: 200>, 'IPPREFIX': <TokenType.IPPREFIX: 201>, 'TDIGEST': <TokenType.TDIGEST: 212>, 'HYPERLOGLOG': <TokenType.HLLSKETCH: 184>}
BYTE_STRING_ESCAPES: ClassVar[list[str]] = ["'"]