14class Athena(Dialect):
15    """
16    Over the years, it looks like AWS has taken various execution engines, bolted on AWS-specific
17    modifications and then built the Athena service around them.
18
19    Thus, Athena is not simply hosted Trino, it's more like a router that routes SQL queries to an
20    execution engine depending on the query type.
21
22    As at 2024-09-10, assuming your Athena workgroup is configured to use "Athena engine version 3",
23    the following engines exist:
24
25    Hive:
26     - Accepts mostly the same syntax as Hadoop / Hive
27     - Uses backticks to quote identifiers
28     - Has a distinctive DDL syntax (around things like setting table properties, storage locations etc)
29       that is different from Trino
30     - Used for *most* DDL, with some exceptions that get routed to the Trino engine instead:
31        - CREATE [EXTERNAL] TABLE (without AS SELECT)
32        - ALTER
33        - DROP
34
35    Trino:
36      - Uses double quotes to quote identifiers
37      - Used for DDL operations that involve SELECT queries, eg:
38        - CREATE VIEW / DROP VIEW
39        - CREATE TABLE... AS SELECT
40      - Used for DML operations
41        - SELECT, INSERT, UPDATE, DELETE, MERGE
42
43    The SQLGlot Athena dialect tries to identify which engine a query would be routed to and then uses the
44    tokenizer / parser / generator for that engine. This is unfortunately necessary, as there are certain
45    incompatibilities between the engines' dialects and thus can't be handled by a single, unifying dialect.
46
47    References:
48    - https://docs.aws.amazon.com/athena/latest/ug/ddl-reference.html
49    - https://docs.aws.amazon.com/athena/latest/ug/dml-queries-functions-operators.html
50    """
51
52    # This Tokenizer consumes a combination of HiveQL and Trino SQL and then processes the tokens
53    # to disambiguate which dialect needs to be actually used in order to tokenize correctly.
54    class Tokenizer(tokens.Tokenizer):
55        IDENTIFIERS = Trino.Tokenizer.IDENTIFIERS + Hive.Tokenizer.IDENTIFIERS
56        STRING_ESCAPES = Trino.Tokenizer.STRING_ESCAPES + Hive.Tokenizer.STRING_ESCAPES
57        HEX_STRINGS = Trino.Tokenizer.HEX_STRINGS + Hive.Tokenizer.HEX_STRINGS
58        UNICODE_STRINGS = Trino.Tokenizer.UNICODE_STRINGS + Hive.Tokenizer.UNICODE_STRINGS
59
60        NUMERIC_LITERALS = {
61            **Trino.Tokenizer.NUMERIC_LITERALS,
62            **Hive.Tokenizer.NUMERIC_LITERALS,
63        }
64
65        KEYWORDS = {
66            **Hive.Tokenizer.KEYWORDS,
67            **Trino.Tokenizer.KEYWORDS,
68            "UNLOAD": TokenType.COMMAND,
69        }
70
71        def __init__(self, dialect: DialectType = None) -> None:
72            super().__init__(dialect=dialect)
73
74            self._hive_tokenizer = Hive().tokenizer()
75            self._trino_tokenizer = _TrinoTokenizer(Trino())
76
77        def tokenize(self, sql: str) -> list[Token]:
78            tokens = super().tokenize(sql)
79
80            if _tokenize_as_hive(tokens):
81                return [Token(TokenType.HIVE_TOKEN_STREAM, "")] + self._hive_tokenizer.tokenize(sql)
82
83            return self._trino_tokenizer.tokenize(sql)
84
85    Parser = AthenaParser
86
87    Generator = AthenaGenerator

54    class Tokenizer(tokens.Tokenizer):
55        IDENTIFIERS = Trino.Tokenizer.IDENTIFIERS + Hive.Tokenizer.IDENTIFIERS
56        STRING_ESCAPES = Trino.Tokenizer.STRING_ESCAPES + Hive.Tokenizer.STRING_ESCAPES
57        HEX_STRINGS = Trino.Tokenizer.HEX_STRINGS + Hive.Tokenizer.HEX_STRINGS
58        UNICODE_STRINGS = Trino.Tokenizer.UNICODE_STRINGS + Hive.Tokenizer.UNICODE_STRINGS
59
60        NUMERIC_LITERALS = {
61            **Trino.Tokenizer.NUMERIC_LITERALS,
62            **Hive.Tokenizer.NUMERIC_LITERALS,
63        }
64
65        KEYWORDS = {
66            **Hive.Tokenizer.KEYWORDS,
67            **Trino.Tokenizer.KEYWORDS,
68            "UNLOAD": TokenType.COMMAND,
69        }
70
71        def __init__(self, dialect: DialectType = None) -> None:
72            super().__init__(dialect=dialect)
73
74            self._hive_tokenizer = Hive().tokenizer()
75            self._trino_tokenizer = _TrinoTokenizer(Trino())
76
77        def tokenize(self, sql: str) -> list[Token]:
78            tokens = super().tokenize(sql)
79
80            if _tokenize_as_hive(tokens):
81                return [Token(TokenType.HIVE_TOKEN_STREAM, "")] + self._hive_tokenizer.tokenize(sql)
82
83            return self._trino_tokenizer.tokenize(sql)

 25class BigQuery(Dialect):
 26    WEEK_OFFSET = -1
 27    UNNEST_COLUMN_ONLY = True
 28    SUPPORTS_USER_DEFINED_TYPES = False
 29    LOG_BASE_FIRST = False
 30    HEX_LOWERCASE = True
 31    FORCE_EARLY_ALIAS_REF_EXPANSION = True
 32    EXPAND_ONLY_GROUP_ALIAS_REF = True
 33    PRESERVE_ORIGINAL_NAMES = True
 34    HEX_STRING_IS_INTEGER_TYPE = True
 35    BYTE_STRING_IS_BYTES_TYPE = True
 36    UUID_IS_STRING_TYPE = True
 37    ANNOTATE_ALL_SCOPES = True
 38    PROJECTION_ALIASES_SHADOW_SOURCE_NAMES = True
 39    TABLES_REFERENCEABLE_AS_COLUMNS = True
 40    SUPPORTS_STRUCT_STAR_EXPANSION = True
 41    EXCLUDES_PSEUDOCOLUMNS_FROM_STAR = True
 42    QUERY_RESULTS_ARE_STRUCTS = True
 43    JSON_EXTRACT_SCALAR_SCALAR_ONLY = True
 44    JSON_PATH_SINGLE_DOT_IS_WILDCARD = True
 45    LEAST_GREATEST_IGNORES_NULLS = False
 46    DEFAULT_NULL_TYPE = exp.DType.BIGINT
 47    PRIORITIZE_NON_LITERAL_TYPES = True
 48    ALIAS_POST_VERSION = False
 49
 50    # https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#initcap
 51    INITCAP_DEFAULT_DELIMITER_CHARS = ' \t\n\r\f\v\\[\\](){}/|<>!?@"^#$&~_,.:;*%+\\-'
 52
 53    # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#case_sensitivity
 54    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
 55    ASCII_ONLY_NORMALIZATION = True
 56
 57    # bigquery udfs are case sensitive
 58    NORMALIZE_FUNCTIONS = False
 59
 60    # https://cloud.google.com/bigquery/docs/reference/standard-sql/format-elements#format_elements_date_time
 61    TIME_MAPPING = {
 62        "%x": "%m/%d/%y",
 63        "%D": "%m/%d/%y",
 64        "%E6S": "%S.%f",
 65        "%e": "%-d",
 66        "%F": "%Y-%m-%d",
 67        "%T": "%H:%M:%S",
 68        "%c": "%a %b %e %H:%M:%S %Y",
 69    }
 70
 71    INVERSE_TIME_MAPPING = {
 72        # Preserve %E6S instead of expanding to %T.%f - since both %E6S & %T.%f are semantically different in BigQuery
 73        # %E6S is semantically different from %T.%f: %E6S works as a single atomic specifier for seconds with microseconds, while %T.%f expands incorrectly and fails to parse.
 74        "%H:%M:%S.%f": "%H:%M:%E6S",
 75    }
 76
 77    FORMAT_MAPPING = {
 78        "dd": "%d",
 79        "DD": "%d",
 80        "mm": "%m",
 81        "MM": "%m",
 82        "mon": "%b",
 83        "MON": "%b",
 84        "month": "%B",
 85        "MONTH": "%B",
 86        "yyyy": "%Y",
 87        "YYYY": "%Y",
 88        "yy": "%y",
 89        "YY": "%y",
 90        "HH": "%I",
 91        "HH12": "%I",
 92        "hh24": "%H",
 93        "HH24": "%H",
 94        "mi": "%M",
 95        "MI": "%M",
 96        "ss": "%S",
 97        "SS": "%S",
 98        "SSSSS": "%f",
 99        "tzh": "%z",
100        "TZH": "%z",
101    }
102
103    # The _PARTITIONTIME and _PARTITIONDATE pseudo-columns are not returned by a SELECT * statement
104    # https://cloud.google.com/bigquery/docs/querying-partitioned-tables#query_an_ingestion-time_partitioned_table
105    # https://cloud.google.com/bigquery/docs/querying-wildcard-tables#scanning_a_range_of_tables_using_table_suffix
106    # https://cloud.google.com/bigquery/docs/query-cloud-storage-data#query_the_file_name_pseudo-column
107    PSEUDOCOLUMNS = {
108        "_PARTITIONTIME",
109        "_PARTITIONDATE",
110        "_TABLE_SUFFIX",
111        "_FILE_NAME",
112        "_DBT_MAX_PARTITION",
113    }
114
115    # All set operations require either a DISTINCT or ALL specifier
116    SET_OP_DISTINCT_BY_DEFAULT = dict.fromkeys((exp.Except, exp.Intersect, exp.Union), None)
117
118    # https://cloud.google.com/bigquery/docs/reference/standard-sql/navigation_functions#percentile_cont
119    COERCES_TO = {
120        **TypeAnnotator.COERCES_TO,
121        exp.DType.BIGDECIMAL: {exp.DType.DOUBLE},
122    }
123    COERCES_TO[exp.DType.DECIMAL] |= {exp.DType.BIGDECIMAL}
124    COERCES_TO[exp.DType.BIGINT] |= {exp.DType.BIGDECIMAL}
125    COERCES_TO[exp.DType.VARCHAR] |= {
126        exp.DType.DATE,
127        exp.DType.DATETIME,
128        exp.DType.TIME,
129        exp.DType.TIMESTAMP,
130        exp.DType.TIMESTAMPTZ,
131    }
132
133    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
134
135    def normalize_identifier(self, expression: E) -> E:
136        if (
137            isinstance(expression, exp.Identifier)
138            and self.normalization_strategy is NormalizationStrategy.CASE_INSENSITIVE
139        ):
140            parent = expression.parent
141            while isinstance(parent, exp.Dot):
142                parent = parent.parent
143
144            # In BigQuery, CTEs are case-insensitive, but UDF and table names are case-sensitive
145            # by default. The following check uses a heuristic to detect tables based on whether
146            # they are qualified. This should generally be correct, because tables in BigQuery
147            # must be qualified with at least a dataset, unless @@dataset_id is set.
148            case_sensitive = (
149                isinstance(parent, exp.UserDefinedFunction)
150                or (
151                    isinstance(parent, exp.Table)
152                    and parent.db
153                    and (parent.meta_get("quoted_table") or not parent.meta_get("maybe_column"))
154                )
155                or expression.meta_get("is_table")
156            )
157            if not case_sensitive:
158                expression.set("this", expression.this.translate(ASCII_LOWER))
159
160            return t.cast(E, expression)
161
162        return super().normalize_identifier(expression)
163
164    class JSONPathTokenizer(jsonpath.JSONPathTokenizer):
165        VAR_TOKENS = {
166            *jsonpath.JSONPathTokenizer.VAR_TOKENS,
167            TokenType.DASH,
168            TokenType.NUMBER,
169        }
170
171    class Tokenizer(tokens.Tokenizer):
172        QUOTES = ["'", '"', '"""', "'''"]
173        COMMENTS = ["--", "#", ("/*", "*/")]
174        IDENTIFIERS = ["`"]
175        STRING_ESCAPES = ["\\"]
176
177        HEX_STRINGS = [("0x", ""), ("0X", "")]
178
179        BYTE_STRINGS = [(prefix + q, q) for q in t.cast(list[str], QUOTES) for prefix in ("b", "B")]
180
181        RAW_STRINGS = [(prefix + q, q) for q in t.cast(list[str], QUOTES) for prefix in ("r", "R")]
182
183        NESTED_COMMENTS = False
184
185        KEYWORDS = {
186            **tokens.Tokenizer.KEYWORDS,
187            "ANY TYPE": TokenType.VARIANT,
188            "BEGIN": TokenType.COMMAND,
189            "BEGIN TRANSACTION": TokenType.BEGIN,
190            "BYTEINT": TokenType.INT,
191            "BYTES": TokenType.BINARY,
192            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
193            "DATETIME": TokenType.TIMESTAMP,
194            "DECLARE": TokenType.DECLARE,
195            "ELSEIF": TokenType.COMMAND,
196            "EXCEPTION": TokenType.COMMAND,
197            "EXPORT": TokenType.EXPORT,
198            "FLOAT64": TokenType.DOUBLE,
199            "LOOP": TokenType.COMMAND,
200            "MODEL": TokenType.MODEL,
201            "RECORD": TokenType.STRUCT,
202            "REPEAT": TokenType.COMMAND,
203            "TIMESTAMP": TokenType.TIMESTAMPTZ,
204            "WHILE": TokenType.COMMAND,
205        }
206        KEYWORDS.pop("DIV")
207        KEYWORDS.pop("VALUES")
208        KEYWORDS.pop("/*+")
209
210    Parser = BigQueryParser
211
212    Generator = BigQueryGenerator

164    class JSONPathTokenizer(jsonpath.JSONPathTokenizer):
165        VAR_TOKENS = {
166            *jsonpath.JSONPathTokenizer.VAR_TOKENS,
167            TokenType.DASH,
168            TokenType.NUMBER,
169        }

171    class Tokenizer(tokens.Tokenizer):
172        QUOTES = ["'", '"', '"""', "'''"]
173        COMMENTS = ["--", "#", ("/*", "*/")]
174        IDENTIFIERS = ["`"]
175        STRING_ESCAPES = ["\\"]
176
177        HEX_STRINGS = [("0x", ""), ("0X", "")]
178
179        BYTE_STRINGS = [(prefix + q, q) for q in t.cast(list[str], QUOTES) for prefix in ("b", "B")]
180
181        RAW_STRINGS = [(prefix + q, q) for q in t.cast(list[str], QUOTES) for prefix in ("r", "R")]
182
183        NESTED_COMMENTS = False
184
185        KEYWORDS = {
186            **tokens.Tokenizer.KEYWORDS,
187            "ANY TYPE": TokenType.VARIANT,
188            "BEGIN": TokenType.COMMAND,
189            "BEGIN TRANSACTION": TokenType.BEGIN,
190            "BYTEINT": TokenType.INT,
191            "BYTES": TokenType.BINARY,
192            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
193            "DATETIME": TokenType.TIMESTAMP,
194            "DECLARE": TokenType.DECLARE,
195            "ELSEIF": TokenType.COMMAND,
196            "EXCEPTION": TokenType.COMMAND,
197            "EXPORT": TokenType.EXPORT,
198            "FLOAT64": TokenType.DOUBLE,
199            "LOOP": TokenType.COMMAND,
200            "MODEL": TokenType.MODEL,
201            "RECORD": TokenType.STRUCT,
202            "REPEAT": TokenType.COMMAND,
203            "TIMESTAMP": TokenType.TIMESTAMPTZ,
204            "WHILE": TokenType.COMMAND,
205        }
206        KEYWORDS.pop("DIV")
207        KEYWORDS.pop("VALUES")
208        KEYWORDS.pop("/*+")

 16class ClickHouse(Dialect):
 17    INDEX_OFFSET = 1
 18    NORMALIZE_FUNCTIONS: bool | str = False
 19    NULL_ORDERING = "nulls_are_last"
 20    SUPPORTS_USER_DEFINED_TYPES = False
 21    LOG_BASE_FIRST: bool | None = None
 22    FORCE_EARLY_ALIAS_REF_EXPANSION = True
 23    PRESERVE_ORIGINAL_NAMES = True
 24    NUMBERS_CAN_BE_UNDERSCORE_SEPARATED = True
 25    IDENTIFIERS_CAN_START_WITH_DIGIT = True
 26    HEX_STRING_IS_INTEGER_TYPE = True
 27
 28    # https://github.com/ClickHouse/ClickHouse/issues/33935#issue-1112165779
 29    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_SENSITIVE
 30
 31    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
 32
 33    UNESCAPED_SEQUENCES = {
 34        "\\0": "\0",
 35    }
 36
 37    CREATABLE_KIND_MAPPING = {"DATABASE": "SCHEMA"}
 38
 39    SET_OP_DISTINCT_BY_DEFAULT: dict[type[exp.Expr], bool | None] = {
 40        exp.Except: False,
 41        exp.Intersect: False,
 42        exp.Union: None,
 43    }
 44
 45    def generate_values_aliases(self, expression: exp.Values) -> list[exp.Identifier]:
 46        # Clickhouse allows VALUES to have an embedded structure e.g:
 47        # VALUES('person String, place String', ('Noah', 'Paris'), ...)
 48        # In this case, we don't want to qualify the columns
 49        values = expression.expressions[0].expressions
 50
 51        structure = (
 52            values[0]
 53            if (len(values) > 1 and values[0].is_string and isinstance(values[1], exp.Tuple))
 54            else None
 55        )
 56        if structure:
 57            # Split each column definition into the column name e.g:
 58            # 'person String, place String' -> ['person', 'place']
 59            structure_coldefs = [coldef.strip() for coldef in structure.name.split(",")]
 60            column_aliases = [
 61                exp.to_identifier(coldef.split(" ")[0]) for coldef in structure_coldefs
 62            ]
 63        else:
 64            # Default column aliases in CH are "c1", "c2", etc.
 65            column_aliases = [
 66                exp.to_identifier(f"c{i + 1}") for i in range(len(values[0].expressions))
 67            ]
 68
 69        return column_aliases
 70
 71    class Tokenizer(tokens.Tokenizer):
 72        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
 73        IDENTIFIERS = ['"', "`"]
 74        IDENTIFIER_ESCAPES = ["\\"]
 75        STRING_ESCAPES = ["'", "\\"]
 76        BIT_STRINGS = [("0b", "")]
 77        HEX_STRINGS = [("0x", ""), ("0X", "")]
 78        HEREDOC_STRINGS = ["$"]
 79
 80        KEYWORDS = {
 81            **tokens.Tokenizer.KEYWORDS,
 82            ".:": TokenType.DOTCOLON,
 83            ".^": TokenType.DOTCARET,
 84            "ATTACH": TokenType.COMMAND,
 85            "DATE32": TokenType.DATE32,
 86            "DETACH": TokenType.DETACH,
 87            "DATETIME64": TokenType.DATETIME64,
 88            "DICTIONARY": TokenType.DICTIONARY,
 89            "DYNAMIC": TokenType.DYNAMIC,
 90            "ENUM8": TokenType.ENUM8,
 91            "ENUM16": TokenType.ENUM16,
 92            "EXCHANGE": TokenType.COMMAND,
 93            "FINAL": TokenType.FINAL,
 94            "FIXEDSTRING": TokenType.FIXEDSTRING,
 95            "FLOAT32": TokenType.FLOAT,
 96            "FLOAT64": TokenType.DOUBLE,
 97            "GLOBAL": TokenType.GLOBAL,
 98            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
 99            "MAP": TokenType.MAP,
100            "NESTED": TokenType.NESTED,
101            "NOTHING": TokenType.NOTHING,
102            "SAMPLE": TokenType.TABLE_SAMPLE,
103            "TUPLE": TokenType.STRUCT,
104            "UINT16": TokenType.USMALLINT,
105            "UINT32": TokenType.UINT,
106            "UINT64": TokenType.UBIGINT,
107            "UINT8": TokenType.UTINYINT,
108            "IPV4": TokenType.IPV4,
109            "IPV6": TokenType.IPV6,
110            "POINT": TokenType.POINT,
111            "PROJECTION": TokenType.PROJECTION,
112            "RING": TokenType.RING,
113            "LINESTRING": TokenType.LINESTRING,
114            "MULTILINESTRING": TokenType.MULTILINESTRING,
115            "POLYGON": TokenType.POLYGON,
116            "MULTIPOLYGON": TokenType.MULTIPOLYGON,
117            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
118            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
119            "SYSTEM": TokenType.COMMAND,
120            "PREWHERE": TokenType.PREWHERE,
121        }
122
123        KEYWORDS.pop("/*+")
124
125        SINGLE_TOKENS = {
126            **tokens.Tokenizer.SINGLE_TOKENS,
127            "$": TokenType.HEREDOC_STRING,
128        }
129
130    Parser = ClickHouseParser
131
132    Generator = ClickHouseGenerator

 71    class Tokenizer(tokens.Tokenizer):
 72        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
 73        IDENTIFIERS = ['"', "`"]
 74        IDENTIFIER_ESCAPES = ["\\"]
 75        STRING_ESCAPES = ["'", "\\"]
 76        BIT_STRINGS = [("0b", "")]
 77        HEX_STRINGS = [("0x", ""), ("0X", "")]
 78        HEREDOC_STRINGS = ["$"]
 79
 80        KEYWORDS = {
 81            **tokens.Tokenizer.KEYWORDS,
 82            ".:": TokenType.DOTCOLON,
 83            ".^": TokenType.DOTCARET,
 84            "ATTACH": TokenType.COMMAND,
 85            "DATE32": TokenType.DATE32,
 86            "DETACH": TokenType.DETACH,
 87            "DATETIME64": TokenType.DATETIME64,
 88            "DICTIONARY": TokenType.DICTIONARY,
 89            "DYNAMIC": TokenType.DYNAMIC,
 90            "ENUM8": TokenType.ENUM8,
 91            "ENUM16": TokenType.ENUM16,
 92            "EXCHANGE": TokenType.COMMAND,
 93            "FINAL": TokenType.FINAL,
 94            "FIXEDSTRING": TokenType.FIXEDSTRING,
 95            "FLOAT32": TokenType.FLOAT,
 96            "FLOAT64": TokenType.DOUBLE,
 97            "GLOBAL": TokenType.GLOBAL,
 98            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
 99            "MAP": TokenType.MAP,
100            "NESTED": TokenType.NESTED,
101            "NOTHING": TokenType.NOTHING,
102            "SAMPLE": TokenType.TABLE_SAMPLE,
103            "TUPLE": TokenType.STRUCT,
104            "UINT16": TokenType.USMALLINT,
105            "UINT32": TokenType.UINT,
106            "UINT64": TokenType.UBIGINT,
107            "UINT8": TokenType.UTINYINT,
108            "IPV4": TokenType.IPV4,
109            "IPV6": TokenType.IPV6,
110            "POINT": TokenType.POINT,
111            "PROJECTION": TokenType.PROJECTION,
112            "RING": TokenType.RING,
113            "LINESTRING": TokenType.LINESTRING,
114            "MULTILINESTRING": TokenType.MULTILINESTRING,
115            "POLYGON": TokenType.POLYGON,
116            "MULTIPOLYGON": TokenType.MULTIPOLYGON,
117            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
118            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
119            "SYSTEM": TokenType.COMMAND,
120            "PREWHERE": TokenType.PREWHERE,
121        }
122
123        KEYWORDS.pop("/*+")
124
125        SINGLE_TOKENS = {
126            **tokens.Tokenizer.SINGLE_TOKENS,
127            "$": TokenType.HEREDOC_STRING,
128        }

16class Databricks(Spark):
17    SAFE_DIVISION = False
18    COPY_PARAMS_ARE_CSV = False
19    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
20
21    COERCES_TO = defaultdict(set, deepcopy(TypeAnnotator.COERCES_TO))
22    for text_type in exp.DataType.TEXT_TYPES:
23        COERCES_TO[text_type] |= {
24            *exp.DataType.NUMERIC_TYPES,
25            *exp.DataType.TEMPORAL_TYPES,
26            exp.DType.BINARY,
27            exp.DType.BOOLEAN,
28            exp.DType.INTERVAL,
29        }
30
31    class JSONPathTokenizer(Spark.JSONPathTokenizer):
32        IDENTIFIERS = ["`", '"']
33
34    class Tokenizer(Spark.Tokenizer):
35        KEYWORDS = {
36            **Spark.Tokenizer.KEYWORDS,
37            "STREAM": TokenType.STREAM,
38            "VOID": TokenType.VOID,
39        }
40
41    Parser = DatabricksParser
42
43    Generator = DatabricksGenerator