Edit on GitHub

sqlglot.dialects.hive

  1from __future__ import annotations
  2
  3import typing as t
  4from functools import partial
  5
  6from sqlglot import exp, generator, parser, tokens, transforms
  7from sqlglot.dialects.dialect import (
  8    DATE_ADD_OR_SUB,
  9    Dialect,
 10    NormalizationStrategy,
 11    approx_count_distinct_sql,
 12    arg_max_or_min_no_count,
 13    datestrtodate_sql,
 14    build_formatted_time,
 15    if_sql,
 16    is_parse_json,
 17    left_to_substring_sql,
 18    max_or_greatest,
 19    min_or_least,
 20    no_ilike_sql,
 21    no_recursive_cte_sql,
 22    no_trycast_sql,
 23    regexp_extract_sql,
 24    regexp_replace_sql,
 25    rename_func,
 26    right_to_substring_sql,
 27    strposition_sql,
 28    struct_extract_sql,
 29    time_format,
 30    timestrtotime_sql,
 31    unit_to_str,
 32    var_map_sql,
 33    sequence_sql,
 34    property_sql,
 35    build_regexp_extract,
 36)
 37from sqlglot.transforms import (
 38    remove_unique_constraints,
 39    ctas_with_tmp_tables_to_create_tmp_view,
 40    preprocess,
 41    move_schema_columns_to_partitioned_by,
 42)
 43from sqlglot.helper import seq_get
 44from sqlglot.tokens import TokenType
 45from sqlglot.generator import unsupported_args
 46
 47# (FuncType, Multiplier)
 48DATE_DELTA_INTERVAL = {
 49    "YEAR": ("ADD_MONTHS", 12),
 50    "MONTH": ("ADD_MONTHS", 1),
 51    "QUARTER": ("ADD_MONTHS", 3),
 52    "WEEK": ("DATE_ADD", 7),
 53    "DAY": ("DATE_ADD", 1),
 54}
 55
 56TIME_DIFF_FACTOR = {
 57    "MILLISECOND": " * 1000",
 58    "SECOND": "",
 59    "MINUTE": " / 60",
 60    "HOUR": " / 3600",
 61}
 62
 63DIFF_MONTH_SWITCH = ("YEAR", "QUARTER", "MONTH")
 64
 65
 66def _add_date_sql(self: Hive.Generator, expression: DATE_ADD_OR_SUB) -> str:
 67    if isinstance(expression, exp.TsOrDsAdd) and not expression.unit:
 68        return self.func("DATE_ADD", expression.this, expression.expression)
 69
 70    unit = expression.text("unit").upper()
 71    func, multiplier = DATE_DELTA_INTERVAL.get(unit, ("DATE_ADD", 1))
 72
 73    if isinstance(expression, exp.DateSub):
 74        multiplier *= -1
 75
 76    if expression.expression.is_number:
 77        modified_increment = exp.Literal.number(expression.expression.to_py() * multiplier)
 78    else:
 79        modified_increment = expression.expression
 80        if multiplier != 1:
 81            modified_increment = exp.Mul(  # type: ignore
 82                this=modified_increment, expression=exp.Literal.number(multiplier)
 83            )
 84
 85    return self.func(func, expression.this, modified_increment)
 86
 87
 88def _date_diff_sql(self: Hive.Generator, expression: exp.DateDiff | exp.TsOrDsDiff) -> str:
 89    unit = expression.text("unit").upper()
 90
 91    factor = TIME_DIFF_FACTOR.get(unit)
 92    if factor is not None:
 93        left = self.sql(expression, "this")
 94        right = self.sql(expression, "expression")
 95        sec_diff = f"UNIX_TIMESTAMP({left}) - UNIX_TIMESTAMP({right})"
 96        return f"({sec_diff}){factor}" if factor else sec_diff
 97
 98    months_between = unit in DIFF_MONTH_SWITCH
 99    sql_func = "MONTHS_BETWEEN" if months_between else "DATEDIFF"
100    _, multiplier = DATE_DELTA_INTERVAL.get(unit, ("", 1))
101    multiplier_sql = f" / {multiplier}" if multiplier > 1 else ""
102    diff_sql = f"{sql_func}({self.format_args(expression.this, expression.expression)})"
103
104    if months_between or multiplier_sql:
105        # MONTHS_BETWEEN returns a float, so we need to truncate the fractional part.
106        # For the same reason, we want to truncate if there's a divisor present.
107        diff_sql = f"CAST({diff_sql}{multiplier_sql} AS INT)"
108
109    return diff_sql
110
111
112def _json_format_sql(self: Hive.Generator, expression: exp.JSONFormat) -> str:
113    this = expression.this
114
115    if is_parse_json(this):
116        if this.this.is_string:
117            # Since FROM_JSON requires a nested type, we always wrap the json string with
118            # an array to ensure that "naked" strings like "'a'" will be handled correctly
119            wrapped_json = exp.Literal.string(f"[{this.this.name}]")
120
121            from_json = self.func(
122                "FROM_JSON", wrapped_json, self.func("SCHEMA_OF_JSON", wrapped_json)
123            )
124            to_json = self.func("TO_JSON", from_json)
125
126            # This strips the [, ] delimiters of the dummy array printed by TO_JSON
127            return self.func("REGEXP_EXTRACT", to_json, "'^.(.*).$'", "1")
128        return self.sql(this)
129
130    return self.func("TO_JSON", this, expression.args.get("options"))
131
132
133@generator.unsupported_args(("expression", "Hive's SORT_ARRAY does not support a comparator."))
134def _array_sort_sql(self: Hive.Generator, expression: exp.ArraySort) -> str:
135    return self.func("SORT_ARRAY", expression.this)
136
137
138def _str_to_unix_sql(self: Hive.Generator, expression: exp.StrToUnix) -> str:
139    return self.func("UNIX_TIMESTAMP", expression.this, time_format("hive")(self, expression))
140
141
142def _unix_to_time_sql(self: Hive.Generator, expression: exp.UnixToTime) -> str:
143    timestamp = self.sql(expression, "this")
144    scale = expression.args.get("scale")
145    if scale in (None, exp.UnixToTime.SECONDS):
146        return rename_func("FROM_UNIXTIME")(self, expression)
147
148    return f"FROM_UNIXTIME({timestamp} / POW(10, {scale}))"
149
150
151def _str_to_date_sql(self: Hive.Generator, expression: exp.StrToDate) -> str:
152    this = self.sql(expression, "this")
153    time_format = self.format_time(expression)
154    if time_format not in (Hive.TIME_FORMAT, Hive.DATE_FORMAT):
155        this = f"FROM_UNIXTIME(UNIX_TIMESTAMP({this}, {time_format}))"
156    return f"CAST({this} AS DATE)"
157
158
159def _str_to_time_sql(self: Hive.Generator, expression: exp.StrToTime) -> str:
160    this = self.sql(expression, "this")
161    time_format = self.format_time(expression)
162    if time_format not in (Hive.TIME_FORMAT, Hive.DATE_FORMAT):
163        this = f"FROM_UNIXTIME(UNIX_TIMESTAMP({this}, {time_format}))"
164    return f"CAST({this} AS TIMESTAMP)"
165
166
167def _to_date_sql(self: Hive.Generator, expression: exp.TsOrDsToDate) -> str:
168    time_format = self.format_time(expression)
169    if time_format and time_format not in (Hive.TIME_FORMAT, Hive.DATE_FORMAT):
170        return self.func("TO_DATE", expression.this, time_format)
171
172    if isinstance(expression.this, exp.TsOrDsToDate):
173        return self.sql(expression, "this")
174
175    return self.func("TO_DATE", expression.this)
176
177
178def _build_with_ignore_nulls(
179    exp_class: t.Type[exp.Expression],
180) -> t.Callable[[t.List[exp.Expression]], exp.Expression]:
181    def _parse(args: t.List[exp.Expression]) -> exp.Expression:
182        this = exp_class(this=seq_get(args, 0))
183        if seq_get(args, 1) == exp.true():
184            return exp.IgnoreNulls(this=this)
185        return this
186
187    return _parse
188
189
190class Hive(Dialect):
191    ALIAS_POST_TABLESAMPLE = True
192    IDENTIFIERS_CAN_START_WITH_DIGIT = True
193    SUPPORTS_USER_DEFINED_TYPES = False
194    SAFE_DIVISION = True
195    ARRAY_AGG_INCLUDES_NULLS = None
196    REGEXP_EXTRACT_DEFAULT_GROUP = 1
197
198    # https://spark.apache.org/docs/latest/sql-ref-identifier.html#description
199    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
200
201    TIME_MAPPING = {
202        "y": "%Y",
203        "Y": "%Y",
204        "YYYY": "%Y",
205        "yyyy": "%Y",
206        "YY": "%y",
207        "yy": "%y",
208        "MMMM": "%B",
209        "MMM": "%b",
210        "MM": "%m",
211        "M": "%-m",
212        "dd": "%d",
213        "d": "%-d",
214        "HH": "%H",
215        "H": "%-H",
216        "hh": "%I",
217        "h": "%-I",
218        "mm": "%M",
219        "m": "%-M",
220        "ss": "%S",
221        "s": "%-S",
222        "SSSSSS": "%f",
223        "a": "%p",
224        "DD": "%j",
225        "D": "%-j",
226        "E": "%a",
227        "EE": "%a",
228        "EEE": "%a",
229        "EEEE": "%A",
230    }
231
232    DATE_FORMAT = "'yyyy-MM-dd'"
233    DATEINT_FORMAT = "'yyyyMMdd'"
234    TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"
235
236    class Tokenizer(tokens.Tokenizer):
237        QUOTES = ["'", '"']
238        IDENTIFIERS = ["`"]
239        STRING_ESCAPES = ["\\"]
240
241        SINGLE_TOKENS = {
242            **tokens.Tokenizer.SINGLE_TOKENS,
243            "$": TokenType.PARAMETER,
244        }
245
246        KEYWORDS = {
247            **tokens.Tokenizer.KEYWORDS,
248            "ADD ARCHIVE": TokenType.COMMAND,
249            "ADD ARCHIVES": TokenType.COMMAND,
250            "ADD FILE": TokenType.COMMAND,
251            "ADD FILES": TokenType.COMMAND,
252            "ADD JAR": TokenType.COMMAND,
253            "ADD JARS": TokenType.COMMAND,
254            "MINUS": TokenType.EXCEPT,
255            "MSCK REPAIR": TokenType.COMMAND,
256            "REFRESH": TokenType.REFRESH,
257            "TIMESTAMP AS OF": TokenType.TIMESTAMP_SNAPSHOT,
258            "VERSION AS OF": TokenType.VERSION_SNAPSHOT,
259            "SERDEPROPERTIES": TokenType.SERDE_PROPERTIES,
260        }
261
262        NUMERIC_LITERALS = {
263            "L": "BIGINT",
264            "S": "SMALLINT",
265            "Y": "TINYINT",
266            "D": "DOUBLE",
267            "F": "FLOAT",
268            "BD": "DECIMAL",
269        }
270
271    class Parser(parser.Parser):
272        LOG_DEFAULTS_TO_LN = True
273        STRICT_CAST = False
274        VALUES_FOLLOWED_BY_PAREN = False
275
276        FUNCTIONS = {
277            **parser.Parser.FUNCTIONS,
278            "ASCII": exp.Unicode.from_arg_list,
279            "BASE64": exp.ToBase64.from_arg_list,
280            "COLLECT_LIST": lambda args: exp.ArrayAgg(this=seq_get(args, 0), nulls_excluded=True),
281            "COLLECT_SET": exp.ArrayUniqueAgg.from_arg_list,
282            "DATE_ADD": lambda args: exp.TsOrDsAdd(
283                this=seq_get(args, 0), expression=seq_get(args, 1), unit=exp.Literal.string("DAY")
284            ),
285            "DATE_FORMAT": lambda args: build_formatted_time(exp.TimeToStr, "hive")(
286                [
287                    exp.TimeStrToTime(this=seq_get(args, 0)),
288                    seq_get(args, 1),
289                ]
290            ),
291            "DATE_SUB": lambda args: exp.TsOrDsAdd(
292                this=seq_get(args, 0),
293                expression=exp.Mul(this=seq_get(args, 1), expression=exp.Literal.number(-1)),
294                unit=exp.Literal.string("DAY"),
295            ),
296            "DATEDIFF": lambda args: exp.DateDiff(
297                this=exp.TsOrDsToDate(this=seq_get(args, 0)),
298                expression=exp.TsOrDsToDate(this=seq_get(args, 1)),
299            ),
300            "DAY": lambda args: exp.Day(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
301            "FIRST": _build_with_ignore_nulls(exp.First),
302            "FIRST_VALUE": _build_with_ignore_nulls(exp.FirstValue),
303            "FROM_UNIXTIME": build_formatted_time(exp.UnixToStr, "hive", True),
304            "GET_JSON_OBJECT": exp.JSONExtractScalar.from_arg_list,
305            "LAST": _build_with_ignore_nulls(exp.Last),
306            "LAST_VALUE": _build_with_ignore_nulls(exp.LastValue),
307            "MAP": parser.build_var_map,
308            "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate.from_arg_list(args)),
309            "PERCENTILE": exp.Quantile.from_arg_list,
310            "PERCENTILE_APPROX": exp.ApproxQuantile.from_arg_list,
311            "REGEXP_EXTRACT": build_regexp_extract(exp.RegexpExtract),
312            "REGEXP_EXTRACT_ALL": build_regexp_extract(exp.RegexpExtractAll),
313            "SEQUENCE": exp.GenerateSeries.from_arg_list,
314            "SIZE": exp.ArraySize.from_arg_list,
315            "SPLIT": exp.RegexpSplit.from_arg_list,
316            "STR_TO_MAP": lambda args: exp.StrToMap(
317                this=seq_get(args, 0),
318                pair_delim=seq_get(args, 1) or exp.Literal.string(","),
319                key_value_delim=seq_get(args, 2) or exp.Literal.string(":"),
320            ),
321            "TO_DATE": build_formatted_time(exp.TsOrDsToDate, "hive"),
322            "TO_JSON": exp.JSONFormat.from_arg_list,
323            "TRUNC": exp.TimestampTrunc.from_arg_list,
324            "UNBASE64": exp.FromBase64.from_arg_list,
325            "UNIX_TIMESTAMP": lambda args: build_formatted_time(exp.StrToUnix, "hive", True)(
326                args or [exp.CurrentTimestamp()]
327            ),
328            "YEAR": lambda args: exp.Year(this=exp.TsOrDsToDate.from_arg_list(args)),
329        }
330
331        NO_PAREN_FUNCTION_PARSERS = {
332            **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
333            "TRANSFORM": lambda self: self._parse_transform(),
334        }
335
336        NO_PAREN_FUNCTIONS = parser.Parser.NO_PAREN_FUNCTIONS.copy()
337        NO_PAREN_FUNCTIONS.pop(TokenType.CURRENT_TIME)
338
339        PROPERTY_PARSERS = {
340            **parser.Parser.PROPERTY_PARSERS,
341            "SERDEPROPERTIES": lambda self: exp.SerdeProperties(
342                expressions=self._parse_wrapped_csv(self._parse_property)
343            ),
344        }
345
346        def _parse_transform(self) -> t.Optional[exp.Transform | exp.QueryTransform]:
347            if not self._match(TokenType.L_PAREN, advance=False):
348                self._retreat(self._index - 1)
349                return None
350
351            args = self._parse_wrapped_csv(self._parse_lambda)
352            row_format_before = self._parse_row_format(match_row=True)
353
354            record_writer = None
355            if self._match_text_seq("RECORDWRITER"):
356                record_writer = self._parse_string()
357
358            if not self._match(TokenType.USING):
359                return exp.Transform.from_arg_list(args)
360
361            command_script = self._parse_string()
362
363            self._match(TokenType.ALIAS)
364            schema = self._parse_schema()
365
366            row_format_after = self._parse_row_format(match_row=True)
367            record_reader = None
368            if self._match_text_seq("RECORDREADER"):
369                record_reader = self._parse_string()
370
371            return self.expression(
372                exp.QueryTransform,
373                expressions=args,
374                command_script=command_script,
375                schema=schema,
376                row_format_before=row_format_before,
377                record_writer=record_writer,
378                row_format_after=row_format_after,
379                record_reader=record_reader,
380            )
381
382        def _parse_types(
383            self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
384        ) -> t.Optional[exp.Expression]:
385            """
386            Spark (and most likely Hive) treats casts to CHAR(length) and VARCHAR(length) as casts to
387            STRING in all contexts except for schema definitions. For example, this is in Spark v3.4.0:
388
389                spark-sql (default)> select cast(1234 as varchar(2));
390                23/06/06 15:51:18 WARN CharVarcharUtils: The Spark cast operator does not support
391                char/varchar type and simply treats them as string type. Please use string type
392                directly to avoid confusion. Otherwise, you can set spark.sql.legacy.charVarcharAsString
393                to true, so that Spark treat them as string type as same as Spark 3.0 and earlier
394
395                1234
396                Time taken: 4.265 seconds, Fetched 1 row(s)
397
398            This shows that Spark doesn't truncate the value into '12', which is inconsistent with
399            what other dialects (e.g. postgres) do, so we need to drop the length to transpile correctly.
400
401            Reference: https://spark.apache.org/docs/latest/sql-ref-datatypes.html
402            """
403            this = super()._parse_types(
404                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
405            )
406
407            if this and not schema:
408                return this.transform(
409                    lambda node: (
410                        node.replace(exp.DataType.build("text"))
411                        if isinstance(node, exp.DataType) and node.is_type("char", "varchar")
412                        else node
413                    ),
414                    copy=False,
415                )
416
417            return this
418
419        def _parse_partition_and_order(
420            self,
421        ) -> t.Tuple[t.List[exp.Expression], t.Optional[exp.Expression]]:
422            return (
423                (
424                    self._parse_csv(self._parse_assignment)
425                    if self._match_set({TokenType.PARTITION_BY, TokenType.DISTRIBUTE_BY})
426                    else []
427                ),
428                super()._parse_order(skip_order_token=self._match(TokenType.SORT_BY)),
429            )
430
431        def _parse_parameter(self) -> exp.Parameter:
432            self._match(TokenType.L_BRACE)
433            this = self._parse_identifier() or self._parse_primary_or_var()
434            expression = self._match(TokenType.COLON) and (
435                self._parse_identifier() or self._parse_primary_or_var()
436            )
437            self._match(TokenType.R_BRACE)
438            return self.expression(exp.Parameter, this=this, expression=expression)
439
440        def _to_prop_eq(self, expression: exp.Expression, index: int) -> exp.Expression:
441            if isinstance(expression, exp.Column):
442                key = expression.this
443            else:
444                key = exp.to_identifier(f"col{index + 1}")
445
446            return self.expression(exp.PropertyEQ, this=key, expression=expression)
447
448    class Generator(generator.Generator):
449        LIMIT_FETCH = "LIMIT"
450        TABLESAMPLE_WITH_METHOD = False
451        JOIN_HINTS = False
452        TABLE_HINTS = False
453        QUERY_HINTS = False
454        INDEX_ON = "ON TABLE"
455        EXTRACT_ALLOWS_QUOTES = False
456        NVL2_SUPPORTED = False
457        LAST_DAY_SUPPORTS_DATE_PART = False
458        JSON_PATH_SINGLE_QUOTE_ESCAPE = True
459        SUPPORTS_TO_NUMBER = False
460        WITH_PROPERTIES_PREFIX = "TBLPROPERTIES"
461        PARSE_JSON_NAME = None
462        PAD_FILL_PATTERN_IS_REQUIRED = True
463        SUPPORTS_MEDIAN = False
464        ARRAY_SIZE_NAME = "SIZE"
465
466        EXPRESSIONS_WITHOUT_NESTED_CTES = {
467            exp.Insert,
468            exp.Select,
469            exp.Subquery,
470            exp.SetOperation,
471        }
472
473        SUPPORTED_JSON_PATH_PARTS = {
474            exp.JSONPathKey,
475            exp.JSONPathRoot,
476            exp.JSONPathSubscript,
477            exp.JSONPathWildcard,
478        }
479
480        TYPE_MAPPING = {
481            **generator.Generator.TYPE_MAPPING,
482            exp.DataType.Type.BIT: "BOOLEAN",
483            exp.DataType.Type.DATETIME: "TIMESTAMP",
484            exp.DataType.Type.ROWVERSION: "BINARY",
485            exp.DataType.Type.TEXT: "STRING",
486            exp.DataType.Type.TIME: "TIMESTAMP",
487            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
488            exp.DataType.Type.UTINYINT: "SMALLINT",
489            exp.DataType.Type.VARBINARY: "BINARY",
490        }
491
492        TRANSFORMS = {
493            **generator.Generator.TRANSFORMS,
494            exp.Group: transforms.preprocess([transforms.unalias_group]),
495            exp.Property: property_sql,
496            exp.AnyValue: rename_func("FIRST"),
497            exp.ApproxDistinct: approx_count_distinct_sql,
498            exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
499            exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
500            exp.ArrayConcat: rename_func("CONCAT"),
501            exp.ArrayToString: lambda self, e: self.func("CONCAT_WS", e.expression, e.this),
502            exp.ArraySort: _array_sort_sql,
503            exp.With: no_recursive_cte_sql,
504            exp.DateAdd: _add_date_sql,
505            exp.DateDiff: _date_diff_sql,
506            exp.DateStrToDate: datestrtodate_sql,
507            exp.DateSub: _add_date_sql,
508            exp.DateToDi: lambda self,
509            e: f"CAST(DATE_FORMAT({self.sql(e, 'this')}, {Hive.DATEINT_FORMAT}) AS INT)",
510            exp.DiToDate: lambda self,
511            e: f"TO_DATE(CAST({self.sql(e, 'this')} AS STRING), {Hive.DATEINT_FORMAT})",
512            exp.FileFormatProperty: lambda self,
513            e: f"STORED AS {self.sql(e, 'this') if isinstance(e.this, exp.InputOutputFormat) else e.name.upper()}",
514            exp.FromBase64: rename_func("UNBASE64"),
515            exp.GenerateSeries: sequence_sql,
516            exp.GenerateDateArray: sequence_sql,
517            exp.If: if_sql(),
518            exp.ILike: no_ilike_sql,
519            exp.IsNan: rename_func("ISNAN"),
520            exp.JSONExtract: lambda self, e: self.func("GET_JSON_OBJECT", e.this, e.expression),
521            exp.JSONExtractScalar: lambda self, e: self.func(
522                "GET_JSON_OBJECT", e.this, e.expression
523            ),
524            exp.JSONFormat: _json_format_sql,
525            exp.Left: left_to_substring_sql,
526            exp.Map: var_map_sql,
527            exp.Max: max_or_greatest,
528            exp.MD5Digest: lambda self, e: self.func("UNHEX", self.func("MD5", e.this)),
529            exp.Min: min_or_least,
530            exp.MonthsBetween: lambda self, e: self.func("MONTHS_BETWEEN", e.this, e.expression),
531            exp.NotNullColumnConstraint: lambda _, e: (
532                "" if e.args.get("allow_null") else "NOT NULL"
533            ),
534            exp.VarMap: var_map_sql,
535            exp.Create: preprocess(
536                [
537                    remove_unique_constraints,
538                    ctas_with_tmp_tables_to_create_tmp_view,
539                    move_schema_columns_to_partitioned_by,
540                ]
541            ),
542            exp.Quantile: rename_func("PERCENTILE"),
543            exp.ApproxQuantile: rename_func("PERCENTILE_APPROX"),
544            exp.RegexpExtract: regexp_extract_sql,
545            exp.RegexpExtractAll: regexp_extract_sql,
546            exp.RegexpReplace: regexp_replace_sql,
547            exp.RegexpLike: lambda self, e: self.binary(e, "RLIKE"),
548            exp.RegexpSplit: rename_func("SPLIT"),
549            exp.Right: right_to_substring_sql,
550            exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
551            exp.ArrayUniqueAgg: rename_func("COLLECT_SET"),
552            exp.Split: lambda self, e: self.func(
553                "SPLIT", e.this, self.func("CONCAT", "'\\\\Q'", e.expression, "'\\\\E'")
554            ),
555            exp.Select: transforms.preprocess(
556                [
557                    transforms.eliminate_qualify,
558                    transforms.eliminate_distinct_on,
559                    partial(transforms.unnest_to_explode, unnest_using_arrays_zip=False),
560                    transforms.any_to_exists,
561                ]
562            ),
563            exp.StrPosition: lambda self, e: strposition_sql(
564                self, e, func_name="LOCATE", supports_position=True
565            ),
566            exp.StrToDate: _str_to_date_sql,
567            exp.StrToTime: _str_to_time_sql,
568            exp.StrToUnix: _str_to_unix_sql,
569            exp.StructExtract: struct_extract_sql,
570            exp.Table: transforms.preprocess([transforms.unnest_generate_series]),
571            exp.TimeStrToDate: rename_func("TO_DATE"),
572            exp.TimeStrToTime: timestrtotime_sql,
573            exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
574            exp.TimestampTrunc: lambda self, e: self.func("TRUNC", e.this, unit_to_str(e)),
575            exp.TimeToStr: lambda self, e: self.func("DATE_FORMAT", e.this, self.format_time(e)),
576            exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"),
577            exp.ToBase64: rename_func("BASE64"),
578            exp.TsOrDiToDi: lambda self,
579            e: f"CAST(SUBSTR(REPLACE(CAST({self.sql(e, 'this')} AS STRING), '-', ''), 1, 8) AS INT)",
580            exp.TsOrDsAdd: _add_date_sql,
581            exp.TsOrDsDiff: _date_diff_sql,
582            exp.TsOrDsToDate: _to_date_sql,
583            exp.TryCast: no_trycast_sql,
584            exp.Unicode: rename_func("ASCII"),
585            exp.UnixToStr: lambda self, e: self.func(
586                "FROM_UNIXTIME", e.this, time_format("hive")(self, e)
587            ),
588            exp.UnixToTime: _unix_to_time_sql,
589            exp.UnixToTimeStr: rename_func("FROM_UNIXTIME"),
590            exp.Unnest: rename_func("EXPLODE"),
591            exp.PartitionedByProperty: lambda self, e: f"PARTITIONED BY {self.sql(e, 'this')}",
592            exp.NumberToStr: rename_func("FORMAT_NUMBER"),
593            exp.National: lambda self, e: self.national_sql(e, prefix=""),
594            exp.ClusteredColumnConstraint: lambda self,
595            e: f"({self.expressions(e, 'this', indent=False)})",
596            exp.NonClusteredColumnConstraint: lambda self,
597            e: f"({self.expressions(e, 'this', indent=False)})",
598            exp.NotForReplicationColumnConstraint: lambda *_: "",
599            exp.OnProperty: lambda *_: "",
600            exp.PrimaryKeyColumnConstraint: lambda *_: "PRIMARY KEY",
601            exp.WeekOfYear: rename_func("WEEKOFYEAR"),
602            exp.DayOfMonth: rename_func("DAYOFMONTH"),
603            exp.DayOfWeek: rename_func("DAYOFWEEK"),
604            exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
605                rename_func("LEVENSHTEIN")
606            ),
607        }
608
609        PROPERTIES_LOCATION = {
610            **generator.Generator.PROPERTIES_LOCATION,
611            exp.FileFormatProperty: exp.Properties.Location.POST_SCHEMA,
612            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
613            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
614            exp.WithDataProperty: exp.Properties.Location.UNSUPPORTED,
615        }
616
617        def unnest_sql(self, expression: exp.Unnest) -> str:
618            return rename_func("EXPLODE")(self, expression)
619
620        def _jsonpathkey_sql(self, expression: exp.JSONPathKey) -> str:
621            if isinstance(expression.this, exp.JSONPathWildcard):
622                self.unsupported("Unsupported wildcard in JSONPathKey expression")
623                return ""
624
625            return super()._jsonpathkey_sql(expression)
626
627        def parameter_sql(self, expression: exp.Parameter) -> str:
628            this = self.sql(expression, "this")
629            expression_sql = self.sql(expression, "expression")
630
631            parent = expression.parent
632            this = f"{this}:{expression_sql}" if expression_sql else this
633
634            if isinstance(parent, exp.EQ) and isinstance(parent.parent, exp.SetItem):
635                # We need to produce SET key = value instead of SET ${key} = value
636                return this
637
638            return f"${{{this}}}"
639
640        def schema_sql(self, expression: exp.Schema) -> str:
641            for ordered in expression.find_all(exp.Ordered):
642                if ordered.args.get("desc") is False:
643                    ordered.set("desc", None)
644
645            return super().schema_sql(expression)
646
647        def constraint_sql(self, expression: exp.Constraint) -> str:
648            for prop in list(expression.find_all(exp.Properties)):
649                prop.pop()
650
651            this = self.sql(expression, "this")
652            expressions = self.expressions(expression, sep=" ", flat=True)
653            return f"CONSTRAINT {this} {expressions}"
654
655        def rowformatserdeproperty_sql(self, expression: exp.RowFormatSerdeProperty) -> str:
656            serde_props = self.sql(expression, "serde_properties")
657            serde_props = f" {serde_props}" if serde_props else ""
658            return f"ROW FORMAT SERDE {self.sql(expression, 'this')}{serde_props}"
659
660        def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
661            return self.func(
662                "COLLECT_LIST",
663                expression.this.this if isinstance(expression.this, exp.Order) else expression.this,
664            )
665
666        def datatype_sql(self, expression: exp.DataType) -> str:
667            if expression.this in self.PARAMETERIZABLE_TEXT_TYPES and (
668                not expression.expressions or expression.expressions[0].name == "MAX"
669            ):
670                expression = exp.DataType.build("text")
671            elif expression.is_type(exp.DataType.Type.TEXT) and expression.expressions:
672                expression.set("this", exp.DataType.Type.VARCHAR)
673            elif expression.this in exp.DataType.TEMPORAL_TYPES:
674                expression = exp.DataType.build(expression.this)
675            elif expression.is_type("float"):
676                size_expression = expression.find(exp.DataTypeParam)
677                if size_expression:
678                    size = int(size_expression.name)
679                    expression = (
680                        exp.DataType.build("float") if size <= 32 else exp.DataType.build("double")
681                    )
682
683            return super().datatype_sql(expression)
684
685        def version_sql(self, expression: exp.Version) -> str:
686            sql = super().version_sql(expression)
687            return sql.replace("FOR ", "", 1)
688
689        def struct_sql(self, expression: exp.Struct) -> str:
690            values = []
691
692            for i, e in enumerate(expression.expressions):
693                if isinstance(e, exp.PropertyEQ):
694                    self.unsupported("Hive does not support named structs.")
695                    values.append(e.expression)
696                else:
697                    values.append(e)
698
699            return self.func("STRUCT", *values)
700
701        def alterset_sql(self, expression: exp.AlterSet) -> str:
702            exprs = self.expressions(expression, flat=True)
703            exprs = f" {exprs}" if exprs else ""
704            location = self.sql(expression, "location")
705            location = f" LOCATION {location}" if location else ""
706            file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
707            file_format = f" FILEFORMAT {file_format}" if file_format else ""
708            serde = self.sql(expression, "serde")
709            serde = f" SERDE {serde}" if serde else ""
710            tags = self.expressions(expression, key="tag", flat=True, sep="")
711            tags = f" TAGS {tags}" if tags else ""
712
713            return f"SET{serde}{exprs}{location}{file_format}{tags}"
714
715        def serdeproperties_sql(self, expression: exp.SerdeProperties) -> str:
716            prefix = "WITH " if expression.args.get("with") else ""
717            exprs = self.expressions(expression, flat=True)
718
719            return f"{prefix}SERDEPROPERTIES ({exprs})"
720
721        def exists_sql(self, expression: exp.Exists):
722            if expression.expression:
723                return self.function_fallback_sql(expression)
724
725            return super().exists_sql(expression)
DATE_DELTA_INTERVAL = {'YEAR': ('ADD_MONTHS', 12), 'MONTH': ('ADD_MONTHS', 1), 'QUARTER': ('ADD_MONTHS', 3), 'WEEK': ('DATE_ADD', 7), 'DAY': ('DATE_ADD', 1)}
TIME_DIFF_FACTOR = {'MILLISECOND': ' * 1000', 'SECOND': '', 'MINUTE': ' / 60', 'HOUR': ' / 3600'}
DIFF_MONTH_SWITCH = ('YEAR', 'QUARTER', 'MONTH')
class Hive(sqlglot.dialects.dialect.Dialect):
191class Hive(Dialect):
192    ALIAS_POST_TABLESAMPLE = True
193    IDENTIFIERS_CAN_START_WITH_DIGIT = True
194    SUPPORTS_USER_DEFINED_TYPES = False
195    SAFE_DIVISION = True
196    ARRAY_AGG_INCLUDES_NULLS = None
197    REGEXP_EXTRACT_DEFAULT_GROUP = 1
198
199    # https://spark.apache.org/docs/latest/sql-ref-identifier.html#description
200    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
201
202    TIME_MAPPING = {
203        "y": "%Y",
204        "Y": "%Y",
205        "YYYY": "%Y",
206        "yyyy": "%Y",
207        "YY": "%y",
208        "yy": "%y",
209        "MMMM": "%B",
210        "MMM": "%b",
211        "MM": "%m",
212        "M": "%-m",
213        "dd": "%d",
214        "d": "%-d",
215        "HH": "%H",
216        "H": "%-H",
217        "hh": "%I",
218        "h": "%-I",
219        "mm": "%M",
220        "m": "%-M",
221        "ss": "%S",
222        "s": "%-S",
223        "SSSSSS": "%f",
224        "a": "%p",
225        "DD": "%j",
226        "D": "%-j",
227        "E": "%a",
228        "EE": "%a",
229        "EEE": "%a",
230        "EEEE": "%A",
231    }
232
233    DATE_FORMAT = "'yyyy-MM-dd'"
234    DATEINT_FORMAT = "'yyyyMMdd'"
235    TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"
236
237    class Tokenizer(tokens.Tokenizer):
238        QUOTES = ["'", '"']
239        IDENTIFIERS = ["`"]
240        STRING_ESCAPES = ["\\"]
241
242        SINGLE_TOKENS = {
243            **tokens.Tokenizer.SINGLE_TOKENS,
244            "$": TokenType.PARAMETER,
245        }
246
247        KEYWORDS = {
248            **tokens.Tokenizer.KEYWORDS,
249            "ADD ARCHIVE": TokenType.COMMAND,
250            "ADD ARCHIVES": TokenType.COMMAND,
251            "ADD FILE": TokenType.COMMAND,
252            "ADD FILES": TokenType.COMMAND,
253            "ADD JAR": TokenType.COMMAND,
254            "ADD JARS": TokenType.COMMAND,
255            "MINUS": TokenType.EXCEPT,
256            "MSCK REPAIR": TokenType.COMMAND,
257            "REFRESH": TokenType.REFRESH,
258            "TIMESTAMP AS OF": TokenType.TIMESTAMP_SNAPSHOT,
259            "VERSION AS OF": TokenType.VERSION_SNAPSHOT,
260            "SERDEPROPERTIES": TokenType.SERDE_PROPERTIES,
261        }
262
263        NUMERIC_LITERALS = {
264            "L": "BIGINT",
265            "S": "SMALLINT",
266            "Y": "TINYINT",
267            "D": "DOUBLE",
268            "F": "FLOAT",
269            "BD": "DECIMAL",
270        }
271
272    class Parser(parser.Parser):
273        LOG_DEFAULTS_TO_LN = True
274        STRICT_CAST = False
275        VALUES_FOLLOWED_BY_PAREN = False
276
277        FUNCTIONS = {
278            **parser.Parser.FUNCTIONS,
279            "ASCII": exp.Unicode.from_arg_list,
280            "BASE64": exp.ToBase64.from_arg_list,
281            "COLLECT_LIST": lambda args: exp.ArrayAgg(this=seq_get(args, 0), nulls_excluded=True),
282            "COLLECT_SET": exp.ArrayUniqueAgg.from_arg_list,
283            "DATE_ADD": lambda args: exp.TsOrDsAdd(
284                this=seq_get(args, 0), expression=seq_get(args, 1), unit=exp.Literal.string("DAY")
285            ),
286            "DATE_FORMAT": lambda args: build_formatted_time(exp.TimeToStr, "hive")(
287                [
288                    exp.TimeStrToTime(this=seq_get(args, 0)),
289                    seq_get(args, 1),
290                ]
291            ),
292            "DATE_SUB": lambda args: exp.TsOrDsAdd(
293                this=seq_get(args, 0),
294                expression=exp.Mul(this=seq_get(args, 1), expression=exp.Literal.number(-1)),
295                unit=exp.Literal.string("DAY"),
296            ),
297            "DATEDIFF": lambda args: exp.DateDiff(
298                this=exp.TsOrDsToDate(this=seq_get(args, 0)),
299                expression=exp.TsOrDsToDate(this=seq_get(args, 1)),
300            ),
301            "DAY": lambda args: exp.Day(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
302            "FIRST": _build_with_ignore_nulls(exp.First),
303            "FIRST_VALUE": _build_with_ignore_nulls(exp.FirstValue),
304            "FROM_UNIXTIME": build_formatted_time(exp.UnixToStr, "hive", True),
305            "GET_JSON_OBJECT": exp.JSONExtractScalar.from_arg_list,
306            "LAST": _build_with_ignore_nulls(exp.Last),
307            "LAST_VALUE": _build_with_ignore_nulls(exp.LastValue),
308            "MAP": parser.build_var_map,
309            "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate.from_arg_list(args)),
310            "PERCENTILE": exp.Quantile.from_arg_list,
311            "PERCENTILE_APPROX": exp.ApproxQuantile.from_arg_list,
312            "REGEXP_EXTRACT": build_regexp_extract(exp.RegexpExtract),
313            "REGEXP_EXTRACT_ALL": build_regexp_extract(exp.RegexpExtractAll),
314            "SEQUENCE": exp.GenerateSeries.from_arg_list,
315            "SIZE": exp.ArraySize.from_arg_list,
316            "SPLIT": exp.RegexpSplit.from_arg_list,
317            "STR_TO_MAP": lambda args: exp.StrToMap(
318                this=seq_get(args, 0),
319                pair_delim=seq_get(args, 1) or exp.Literal.string(","),
320                key_value_delim=seq_get(args, 2) or exp.Literal.string(":"),
321            ),
322            "TO_DATE": build_formatted_time(exp.TsOrDsToDate, "hive"),
323            "TO_JSON": exp.JSONFormat.from_arg_list,
324            "TRUNC": exp.TimestampTrunc.from_arg_list,
325            "UNBASE64": exp.FromBase64.from_arg_list,
326            "UNIX_TIMESTAMP": lambda args: build_formatted_time(exp.StrToUnix, "hive", True)(
327                args or [exp.CurrentTimestamp()]
328            ),
329            "YEAR": lambda args: exp.Year(this=exp.TsOrDsToDate.from_arg_list(args)),
330        }
331
332        NO_PAREN_FUNCTION_PARSERS = {
333            **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
334            "TRANSFORM": lambda self: self._parse_transform(),
335        }
336
337        NO_PAREN_FUNCTIONS = parser.Parser.NO_PAREN_FUNCTIONS.copy()
338        NO_PAREN_FUNCTIONS.pop(TokenType.CURRENT_TIME)
339
340        PROPERTY_PARSERS = {
341            **parser.Parser.PROPERTY_PARSERS,
342            "SERDEPROPERTIES": lambda self: exp.SerdeProperties(
343                expressions=self._parse_wrapped_csv(self._parse_property)
344            ),
345        }
346
347        def _parse_transform(self) -> t.Optional[exp.Transform | exp.QueryTransform]:
348            if not self._match(TokenType.L_PAREN, advance=False):
349                self._retreat(self._index - 1)
350                return None
351
352            args = self._parse_wrapped_csv(self._parse_lambda)
353            row_format_before = self._parse_row_format(match_row=True)
354
355            record_writer = None
356            if self._match_text_seq("RECORDWRITER"):
357                record_writer = self._parse_string()
358
359            if not self._match(TokenType.USING):
360                return exp.Transform.from_arg_list(args)
361
362            command_script = self._parse_string()
363
364            self._match(TokenType.ALIAS)
365            schema = self._parse_schema()
366
367            row_format_after = self._parse_row_format(match_row=True)
368            record_reader = None
369            if self._match_text_seq("RECORDREADER"):
370                record_reader = self._parse_string()
371
372            return self.expression(
373                exp.QueryTransform,
374                expressions=args,
375                command_script=command_script,
376                schema=schema,
377                row_format_before=row_format_before,
378                record_writer=record_writer,
379                row_format_after=row_format_after,
380                record_reader=record_reader,
381            )
382
383        def _parse_types(
384            self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
385        ) -> t.Optional[exp.Expression]:
386            """
387            Spark (and most likely Hive) treats casts to CHAR(length) and VARCHAR(length) as casts to
388            STRING in all contexts except for schema definitions. For example, this is in Spark v3.4.0:
389
390                spark-sql (default)> select cast(1234 as varchar(2));
391                23/06/06 15:51:18 WARN CharVarcharUtils: The Spark cast operator does not support
392                char/varchar type and simply treats them as string type. Please use string type
393                directly to avoid confusion. Otherwise, you can set spark.sql.legacy.charVarcharAsString
394                to true, so that Spark treat them as string type as same as Spark 3.0 and earlier
395
396                1234
397                Time taken: 4.265 seconds, Fetched 1 row(s)
398
399            This shows that Spark doesn't truncate the value into '12', which is inconsistent with
400            what other dialects (e.g. postgres) do, so we need to drop the length to transpile correctly.
401
402            Reference: https://spark.apache.org/docs/latest/sql-ref-datatypes.html
403            """
404            this = super()._parse_types(
405                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
406            )
407
408            if this and not schema:
409                return this.transform(
410                    lambda node: (
411                        node.replace(exp.DataType.build("text"))
412                        if isinstance(node, exp.DataType) and node.is_type("char", "varchar")
413                        else node
414                    ),
415                    copy=False,
416                )
417
418            return this
419
420        def _parse_partition_and_order(
421            self,
422        ) -> t.Tuple[t.List[exp.Expression], t.Optional[exp.Expression]]:
423            return (
424                (
425                    self._parse_csv(self._parse_assignment)
426                    if self._match_set({TokenType.PARTITION_BY, TokenType.DISTRIBUTE_BY})
427                    else []
428                ),
429                super()._parse_order(skip_order_token=self._match(TokenType.SORT_BY)),
430            )
431
432        def _parse_parameter(self) -> exp.Parameter:
433            self._match(TokenType.L_BRACE)
434            this = self._parse_identifier() or self._parse_primary_or_var()
435            expression = self._match(TokenType.COLON) and (
436                self._parse_identifier() or self._parse_primary_or_var()
437            )
438            self._match(TokenType.R_BRACE)
439            return self.expression(exp.Parameter, this=this, expression=expression)
440
441        def _to_prop_eq(self, expression: exp.Expression, index: int) -> exp.Expression:
442            if isinstance(expression, exp.Column):
443                key = expression.this
444            else:
445                key = exp.to_identifier(f"col{index + 1}")
446
447            return self.expression(exp.PropertyEQ, this=key, expression=expression)
448
449    class Generator(generator.Generator):
450        LIMIT_FETCH = "LIMIT"
451        TABLESAMPLE_WITH_METHOD = False
452        JOIN_HINTS = False
453        TABLE_HINTS = False
454        QUERY_HINTS = False
455        INDEX_ON = "ON TABLE"
456        EXTRACT_ALLOWS_QUOTES = False
457        NVL2_SUPPORTED = False
458        LAST_DAY_SUPPORTS_DATE_PART = False
459        JSON_PATH_SINGLE_QUOTE_ESCAPE = True
460        SUPPORTS_TO_NUMBER = False
461        WITH_PROPERTIES_PREFIX = "TBLPROPERTIES"
462        PARSE_JSON_NAME = None
463        PAD_FILL_PATTERN_IS_REQUIRED = True
464        SUPPORTS_MEDIAN = False
465        ARRAY_SIZE_NAME = "SIZE"
466
467        EXPRESSIONS_WITHOUT_NESTED_CTES = {
468            exp.Insert,
469            exp.Select,
470            exp.Subquery,
471            exp.SetOperation,
472        }
473
474        SUPPORTED_JSON_PATH_PARTS = {
475            exp.JSONPathKey,
476            exp.JSONPathRoot,
477            exp.JSONPathSubscript,
478            exp.JSONPathWildcard,
479        }
480
481        TYPE_MAPPING = {
482            **generator.Generator.TYPE_MAPPING,
483            exp.DataType.Type.BIT: "BOOLEAN",
484            exp.DataType.Type.DATETIME: "TIMESTAMP",
485            exp.DataType.Type.ROWVERSION: "BINARY",
486            exp.DataType.Type.TEXT: "STRING",
487            exp.DataType.Type.TIME: "TIMESTAMP",
488            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
489            exp.DataType.Type.UTINYINT: "SMALLINT",
490            exp.DataType.Type.VARBINARY: "BINARY",
491        }
492
493        TRANSFORMS = {
494            **generator.Generator.TRANSFORMS,
495            exp.Group: transforms.preprocess([transforms.unalias_group]),
496            exp.Property: property_sql,
497            exp.AnyValue: rename_func("FIRST"),
498            exp.ApproxDistinct: approx_count_distinct_sql,
499            exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
500            exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
501            exp.ArrayConcat: rename_func("CONCAT"),
502            exp.ArrayToString: lambda self, e: self.func("CONCAT_WS", e.expression, e.this),
503            exp.ArraySort: _array_sort_sql,
504            exp.With: no_recursive_cte_sql,
505            exp.DateAdd: _add_date_sql,
506            exp.DateDiff: _date_diff_sql,
507            exp.DateStrToDate: datestrtodate_sql,
508            exp.DateSub: _add_date_sql,
509            exp.DateToDi: lambda self,
510            e: f"CAST(DATE_FORMAT({self.sql(e, 'this')}, {Hive.DATEINT_FORMAT}) AS INT)",
511            exp.DiToDate: lambda self,
512            e: f"TO_DATE(CAST({self.sql(e, 'this')} AS STRING), {Hive.DATEINT_FORMAT})",
513            exp.FileFormatProperty: lambda self,
514            e: f"STORED AS {self.sql(e, 'this') if isinstance(e.this, exp.InputOutputFormat) else e.name.upper()}",
515            exp.FromBase64: rename_func("UNBASE64"),
516            exp.GenerateSeries: sequence_sql,
517            exp.GenerateDateArray: sequence_sql,
518            exp.If: if_sql(),
519            exp.ILike: no_ilike_sql,
520            exp.IsNan: rename_func("ISNAN"),
521            exp.JSONExtract: lambda self, e: self.func("GET_JSON_OBJECT", e.this, e.expression),
522            exp.JSONExtractScalar: lambda self, e: self.func(
523                "GET_JSON_OBJECT", e.this, e.expression
524            ),
525            exp.JSONFormat: _json_format_sql,
526            exp.Left: left_to_substring_sql,
527            exp.Map: var_map_sql,
528            exp.Max: max_or_greatest,
529            exp.MD5Digest: lambda self, e: self.func("UNHEX", self.func("MD5", e.this)),
530            exp.Min: min_or_least,
531            exp.MonthsBetween: lambda self, e: self.func("MONTHS_BETWEEN", e.this, e.expression),
532            exp.NotNullColumnConstraint: lambda _, e: (
533                "" if e.args.get("allow_null") else "NOT NULL"
534            ),
535            exp.VarMap: var_map_sql,
536            exp.Create: preprocess(
537                [
538                    remove_unique_constraints,
539                    ctas_with_tmp_tables_to_create_tmp_view,
540                    move_schema_columns_to_partitioned_by,
541                ]
542            ),
543            exp.Quantile: rename_func("PERCENTILE"),
544            exp.ApproxQuantile: rename_func("PERCENTILE_APPROX"),
545            exp.RegexpExtract: regexp_extract_sql,
546            exp.RegexpExtractAll: regexp_extract_sql,
547            exp.RegexpReplace: regexp_replace_sql,
548            exp.RegexpLike: lambda self, e: self.binary(e, "RLIKE"),
549            exp.RegexpSplit: rename_func("SPLIT"),
550            exp.Right: right_to_substring_sql,
551            exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
552            exp.ArrayUniqueAgg: rename_func("COLLECT_SET"),
553            exp.Split: lambda self, e: self.func(
554                "SPLIT", e.this, self.func("CONCAT", "'\\\\Q'", e.expression, "'\\\\E'")
555            ),
556            exp.Select: transforms.preprocess(
557                [
558                    transforms.eliminate_qualify,
559                    transforms.eliminate_distinct_on,
560                    partial(transforms.unnest_to_explode, unnest_using_arrays_zip=False),
561                    transforms.any_to_exists,
562                ]
563            ),
564            exp.StrPosition: lambda self, e: strposition_sql(
565                self, e, func_name="LOCATE", supports_position=True
566            ),
567            exp.StrToDate: _str_to_date_sql,
568            exp.StrToTime: _str_to_time_sql,
569            exp.StrToUnix: _str_to_unix_sql,
570            exp.StructExtract: struct_extract_sql,
571            exp.Table: transforms.preprocess([transforms.unnest_generate_series]),
572            exp.TimeStrToDate: rename_func("TO_DATE"),
573            exp.TimeStrToTime: timestrtotime_sql,
574            exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
575            exp.TimestampTrunc: lambda self, e: self.func("TRUNC", e.this, unit_to_str(e)),
576            exp.TimeToStr: lambda self, e: self.func("DATE_FORMAT", e.this, self.format_time(e)),
577            exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"),
578            exp.ToBase64: rename_func("BASE64"),
579            exp.TsOrDiToDi: lambda self,
580            e: f"CAST(SUBSTR(REPLACE(CAST({self.sql(e, 'this')} AS STRING), '-', ''), 1, 8) AS INT)",
581            exp.TsOrDsAdd: _add_date_sql,
582            exp.TsOrDsDiff: _date_diff_sql,
583            exp.TsOrDsToDate: _to_date_sql,
584            exp.TryCast: no_trycast_sql,
585            exp.Unicode: rename_func("ASCII"),
586            exp.UnixToStr: lambda self, e: self.func(
587                "FROM_UNIXTIME", e.this, time_format("hive")(self, e)
588            ),
589            exp.UnixToTime: _unix_to_time_sql,
590            exp.UnixToTimeStr: rename_func("FROM_UNIXTIME"),
591            exp.Unnest: rename_func("EXPLODE"),
592            exp.PartitionedByProperty: lambda self, e: f"PARTITIONED BY {self.sql(e, 'this')}",
593            exp.NumberToStr: rename_func("FORMAT_NUMBER"),
594            exp.National: lambda self, e: self.national_sql(e, prefix=""),
595            exp.ClusteredColumnConstraint: lambda self,
596            e: f"({self.expressions(e, 'this', indent=False)})",
597            exp.NonClusteredColumnConstraint: lambda self,
598            e: f"({self.expressions(e, 'this', indent=False)})",
599            exp.NotForReplicationColumnConstraint: lambda *_: "",
600            exp.OnProperty: lambda *_: "",
601            exp.PrimaryKeyColumnConstraint: lambda *_: "PRIMARY KEY",
602            exp.WeekOfYear: rename_func("WEEKOFYEAR"),
603            exp.DayOfMonth: rename_func("DAYOFMONTH"),
604            exp.DayOfWeek: rename_func("DAYOFWEEK"),
605            exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
606                rename_func("LEVENSHTEIN")
607            ),
608        }
609
610        PROPERTIES_LOCATION = {
611            **generator.Generator.PROPERTIES_LOCATION,
612            exp.FileFormatProperty: exp.Properties.Location.POST_SCHEMA,
613            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
614            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
615            exp.WithDataProperty: exp.Properties.Location.UNSUPPORTED,
616        }
617
618        def unnest_sql(self, expression: exp.Unnest) -> str:
619            return rename_func("EXPLODE")(self, expression)
620
621        def _jsonpathkey_sql(self, expression: exp.JSONPathKey) -> str:
622            if isinstance(expression.this, exp.JSONPathWildcard):
623                self.unsupported("Unsupported wildcard in JSONPathKey expression")
624                return ""
625
626            return super()._jsonpathkey_sql(expression)
627
628        def parameter_sql(self, expression: exp.Parameter) -> str:
629            this = self.sql(expression, "this")
630            expression_sql = self.sql(expression, "expression")
631
632            parent = expression.parent
633            this = f"{this}:{expression_sql}" if expression_sql else this
634
635            if isinstance(parent, exp.EQ) and isinstance(parent.parent, exp.SetItem):
636                # We need to produce SET key = value instead of SET ${key} = value
637                return this
638
639            return f"${{{this}}}"
640
641        def schema_sql(self, expression: exp.Schema) -> str:
642            for ordered in expression.find_all(exp.Ordered):
643                if ordered.args.get("desc") is False:
644                    ordered.set("desc", None)
645
646            return super().schema_sql(expression)
647
648        def constraint_sql(self, expression: exp.Constraint) -> str:
649            for prop in list(expression.find_all(exp.Properties)):
650                prop.pop()
651
652            this = self.sql(expression, "this")
653            expressions = self.expressions(expression, sep=" ", flat=True)
654            return f"CONSTRAINT {this} {expressions}"
655
656        def rowformatserdeproperty_sql(self, expression: exp.RowFormatSerdeProperty) -> str:
657            serde_props = self.sql(expression, "serde_properties")
658            serde_props = f" {serde_props}" if serde_props else ""
659            return f"ROW FORMAT SERDE {self.sql(expression, 'this')}{serde_props}"
660
661        def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
662            return self.func(
663                "COLLECT_LIST",
664                expression.this.this if isinstance(expression.this, exp.Order) else expression.this,
665            )
666
667        def datatype_sql(self, expression: exp.DataType) -> str:
668            if expression.this in self.PARAMETERIZABLE_TEXT_TYPES and (
669                not expression.expressions or expression.expressions[0].name == "MAX"
670            ):
671                expression = exp.DataType.build("text")
672            elif expression.is_type(exp.DataType.Type.TEXT) and expression.expressions:
673                expression.set("this", exp.DataType.Type.VARCHAR)
674            elif expression.this in exp.DataType.TEMPORAL_TYPES:
675                expression = exp.DataType.build(expression.this)
676            elif expression.is_type("float"):
677                size_expression = expression.find(exp.DataTypeParam)
678                if size_expression:
679                    size = int(size_expression.name)
680                    expression = (
681                        exp.DataType.build("float") if size <= 32 else exp.DataType.build("double")
682                    )
683
684            return super().datatype_sql(expression)
685
686        def version_sql(self, expression: exp.Version) -> str:
687            sql = super().version_sql(expression)
688            return sql.replace("FOR ", "", 1)
689
690        def struct_sql(self, expression: exp.Struct) -> str:
691            values = []
692
693            for i, e in enumerate(expression.expressions):
694                if isinstance(e, exp.PropertyEQ):
695                    self.unsupported("Hive does not support named structs.")
696                    values.append(e.expression)
697                else:
698                    values.append(e)
699
700            return self.func("STRUCT", *values)
701
702        def alterset_sql(self, expression: exp.AlterSet) -> str:
703            exprs = self.expressions(expression, flat=True)
704            exprs = f" {exprs}" if exprs else ""
705            location = self.sql(expression, "location")
706            location = f" LOCATION {location}" if location else ""
707            file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
708            file_format = f" FILEFORMAT {file_format}" if file_format else ""
709            serde = self.sql(expression, "serde")
710            serde = f" SERDE {serde}" if serde else ""
711            tags = self.expressions(expression, key="tag", flat=True, sep="")
712            tags = f" TAGS {tags}" if tags else ""
713
714            return f"SET{serde}{exprs}{location}{file_format}{tags}"
715
716        def serdeproperties_sql(self, expression: exp.SerdeProperties) -> str:
717            prefix = "WITH " if expression.args.get("with") else ""
718            exprs = self.expressions(expression, flat=True)
719
720            return f"{prefix}SERDEPROPERTIES ({exprs})"
721
722        def exists_sql(self, expression: exp.Exists):
723            if expression.expression:
724                return self.function_fallback_sql(expression)
725
726            return super().exists_sql(expression)
ALIAS_POST_TABLESAMPLE = True

Whether the table alias comes after tablesample.

IDENTIFIERS_CAN_START_WITH_DIGIT = True

Whether an unquoted identifier can start with a digit.

SUPPORTS_USER_DEFINED_TYPES = False

Whether user-defined data types are supported.

SAFE_DIVISION = True

Whether division by zero throws an error (False) or returns NULL (True).

ARRAY_AGG_INCLUDES_NULLS: Optional[bool] = None

Whether ArrayAgg needs to filter NULL values.

REGEXP_EXTRACT_DEFAULT_GROUP = 1

The default value for the capturing group.

NORMALIZATION_STRATEGY = <NormalizationStrategy.CASE_INSENSITIVE: 'CASE_INSENSITIVE'>

Specifies the strategy according to which identifiers should be normalized.

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

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

DATE_FORMAT = "'yyyy-MM-dd'"
DATEINT_FORMAT = "'yyyyMMdd'"
TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"
SUPPORTS_COLUMN_JOIN_MARKS = False

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

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

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

tokenizer_class = <class 'Hive.Tokenizer'>
jsonpath_tokenizer_class = <class 'sqlglot.tokens.JSONPathTokenizer'>
parser_class = <class 'Hive.Parser'>
generator_class = <class 'Hive.Generator'>
TIME_TRIE: Dict = {'y': {0: True, 'y': {'y': {'y': {0: True}}, 0: True}}, 'Y': {0: True, 'Y': {'Y': {'Y': {0: True}}, 0: True}}, 'M': {'M': {'M': {'M': {0: True}, 0: True}, 0: True}, 0: True}, 'd': {'d': {0: True}, 0: True}, 'H': {'H': {0: True}, 0: True}, 'h': {'h': {0: True}, 0: True}, 'm': {'m': {0: True}, 0: True}, 's': {'s': {0: True}, 0: True}, 'S': {'S': {'S': {'S': {'S': {'S': {0: True}}}}}}, 'a': {0: True}, 'D': {'D': {0: True}, 0: True}, 'E': {0: True, 'E': {0: True, 'E': {0: True, 'E': {0: True}}}}}
FORMAT_TRIE: Dict = {'y': {0: True, 'y': {'y': {'y': {0: True}}, 0: True}}, 'Y': {0: True, 'Y': {'Y': {'Y': {0: True}}, 0: True}}, 'M': {'M': {'M': {'M': {0: True}, 0: True}, 0: True}, 0: True}, 'd': {'d': {0: True}, 0: True}, 'H': {'H': {0: True}, 0: True}, 'h': {'h': {0: True}, 0: True}, 'm': {'m': {0: True}, 0: True}, 's': {'s': {0: True}, 0: True}, 'S': {'S': {'S': {'S': {'S': {'S': {0: True}}}}}}, 'a': {0: True}, 'D': {'D': {0: True}, 0: True}, 'E': {0: True, 'E': {0: True, 'E': {0: True, 'E': {0: True}}}}}
INVERSE_TIME_MAPPING: Dict[str, str] = {'%Y': 'yyyy', '%y': 'yy', '%B': 'MMMM', '%b': 'MMM', '%m': 'MM', '%-m': 'M', '%d': 'dd', '%-d': 'd', '%H': 'HH', '%-H': 'H', '%I': 'hh', '%-I': 'h', '%M': 'mm', '%-M': 'm', '%S': 'ss', '%-S': 's', '%f': 'SSSSSS', '%p': 'a', '%j': 'DD', '%-j': 'D', '%a': 'EEE', '%A': 'EEEE'}
INVERSE_TIME_TRIE: Dict = {'%': {'Y': {0: True}, 'y': {0: True}, 'B': {0: True}, 'b': {0: True}, 'm': {0: True}, '-': {'m': {0: True}, 'd': {0: True}, 'H': {0: True}, 'I': {0: True}, 'M': {0: True}, 'S': {0: True}, 'j': {0: True}}, 'd': {0: True}, 'H': {0: True}, 'I': {0: True}, 'M': {0: True}, 'S': {0: True}, 'f': {0: True}, 'p': {0: True}, 'j': {0: True}, 'a': {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] = {'\x07': '\\a', '\x08': '\\b', '\x0c': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t', '\x0b': '\\v', '\\': '\\\\'}
QUOTE_START = "'"
QUOTE_END = "'"
IDENTIFIER_START = '`'
IDENTIFIER_END = '`'
BIT_START: Optional[str] = None
BIT_END: Optional[str] = None
HEX_START: Optional[str] = None
HEX_END: Optional[str] = None
BYTE_START: Optional[str] = None
BYTE_END: Optional[str] = None
UNICODE_START: Optional[str] = None
UNICODE_END: Optional[str] = None
class Hive.Tokenizer(sqlglot.tokens.Tokenizer):
237    class Tokenizer(tokens.Tokenizer):
238        QUOTES = ["'", '"']
239        IDENTIFIERS = ["`"]
240        STRING_ESCAPES = ["\\"]
241
242        SINGLE_TOKENS = {
243            **tokens.Tokenizer.SINGLE_TOKENS,
244            "$": TokenType.PARAMETER,
245        }
246
247        KEYWORDS = {
248            **tokens.Tokenizer.KEYWORDS,
249            "ADD ARCHIVE": TokenType.COMMAND,
250            "ADD ARCHIVES": TokenType.COMMAND,
251            "ADD FILE": TokenType.COMMAND,
252            "ADD FILES": TokenType.COMMAND,
253            "ADD JAR": TokenType.COMMAND,
254            "ADD JARS": TokenType.COMMAND,
255            "MINUS": TokenType.EXCEPT,
256            "MSCK REPAIR": TokenType.COMMAND,
257            "REFRESH": TokenType.REFRESH,
258            "TIMESTAMP AS OF": TokenType.TIMESTAMP_SNAPSHOT,
259            "VERSION AS OF": TokenType.VERSION_SNAPSHOT,
260            "SERDEPROPERTIES": TokenType.SERDE_PROPERTIES,
261        }
262
263        NUMERIC_LITERALS = {
264            "L": "BIGINT",
265            "S": "SMALLINT",
266            "Y": "TINYINT",
267            "D": "DOUBLE",
268            "F": "FLOAT",
269            "BD": "DECIMAL",
270        }
QUOTES = ["'", '"']
IDENTIFIERS = ['`']
STRING_ESCAPES = ['\\']
SINGLE_TOKENS = {'(': <TokenType.L_PAREN: 'L_PAREN'>, ')': <TokenType.R_PAREN: 'R_PAREN'>, '[': <TokenType.L_BRACKET: 'L_BRACKET'>, ']': <TokenType.R_BRACKET: 'R_BRACKET'>, '{': <TokenType.L_BRACE: 'L_BRACE'>, '}': <TokenType.R_BRACE: 'R_BRACE'>, '&': <TokenType.AMP: 'AMP'>, '^': <TokenType.CARET: 'CARET'>, ':': <TokenType.COLON: 'COLON'>, ',': <TokenType.COMMA: 'COMMA'>, '.': <TokenType.DOT: 'DOT'>, '-': <TokenType.DASH: 'DASH'>, '=': <TokenType.EQ: 'EQ'>, '>': <TokenType.GT: 'GT'>, '<': <TokenType.LT: 'LT'>, '%': <TokenType.MOD: 'MOD'>, '!': <TokenType.NOT: 'NOT'>, '|': <TokenType.PIPE: 'PIPE'>, '+': <TokenType.PLUS: 'PLUS'>, ';': <TokenType.SEMICOLON: 'SEMICOLON'>, '/': <TokenType.SLASH: 'SLASH'>, '\\': <TokenType.BACKSLASH: 'BACKSLASH'>, '*': <TokenType.STAR: 'STAR'>, '~': <TokenType.TILDA: 'TILDA'>, '?': <TokenType.PLACEHOLDER: 'PLACEHOLDER'>, '@': <TokenType.PARAMETER: 'PARAMETER'>, '#': <TokenType.HASH: 'HASH'>, "'": <TokenType.UNKNOWN: 'UNKNOWN'>, '`': <TokenType.UNKNOWN: 'UNKNOWN'>, '"': <TokenType.UNKNOWN: 'UNKNOWN'>, '$': <TokenType.PARAMETER: 'PARAMETER'>}
KEYWORDS = {'{%': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%-': <TokenType.BLOCK_START: 'BLOCK_START'>, '%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '+%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '{{+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{{-': <TokenType.BLOCK_START: 'BLOCK_START'>, '+}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '/*+': <TokenType.HINT: 'HINT'>, '==': <TokenType.EQ: 'EQ'>, '::': <TokenType.DCOLON: 'DCOLON'>, '||': <TokenType.DPIPE: 'DPIPE'>, '>=': <TokenType.GTE: 'GTE'>, '<=': <TokenType.LTE: 'LTE'>, '<>': <TokenType.NEQ: 'NEQ'>, '!=': <TokenType.NEQ: 'NEQ'>, ':=': <TokenType.COLON_EQ: 'COLON_EQ'>, '<=>': <TokenType.NULLSAFE_EQ: 'NULLSAFE_EQ'>, '->': <TokenType.ARROW: 'ARROW'>, '->>': <TokenType.DARROW: 'DARROW'>, '=>': <TokenType.FARROW: 'FARROW'>, '#>': <TokenType.HASH_ARROW: 'HASH_ARROW'>, '#>>': <TokenType.DHASH_ARROW: 'DHASH_ARROW'>, '<->': <TokenType.LR_ARROW: 'LR_ARROW'>, '&&': <TokenType.DAMP: 'DAMP'>, '??': <TokenType.DQMARK: 'DQMARK'>, '~~~': <TokenType.GLOB: 'GLOB'>, '~~': <TokenType.LIKE: 'LIKE'>, '~~*': <TokenType.ILIKE: 'ILIKE'>, '~*': <TokenType.IRLIKE: 'IRLIKE'>, 'ALL': <TokenType.ALL: 'ALL'>, 'ALWAYS': <TokenType.ALWAYS: 'ALWAYS'>, 'AND': <TokenType.AND: 'AND'>, 'ANTI': <TokenType.ANTI: 'ANTI'>, 'ANY': <TokenType.ANY: 'ANY'>, 'ASC': <TokenType.ASC: 'ASC'>, 'AS': <TokenType.ALIAS: 'ALIAS'>, 'ASOF': <TokenType.ASOF: 'ASOF'>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'BEGIN': <TokenType.BEGIN: 'BEGIN'>, 'BETWEEN': <TokenType.BETWEEN: 'BETWEEN'>, 'CACHE': <TokenType.CACHE: 'CACHE'>, 'UNCACHE': <TokenType.UNCACHE: 'UNCACHE'>, 'CASE': <TokenType.CASE: 'CASE'>, 'CHARACTER SET': <TokenType.CHARACTER_SET: 'CHARACTER_SET'>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 'CLUSTER_BY'>, 'COLLATE': <TokenType.COLLATE: 'COLLATE'>, 'COLUMN': <TokenType.COLUMN: 'COLUMN'>, 'COMMIT': <TokenType.COMMIT: 'COMMIT'>, 'CONNECT BY': <TokenType.CONNECT_BY: 'CONNECT_BY'>, 'CONSTRAINT': <TokenType.CONSTRAINT: 'CONSTRAINT'>, 'COPY': <TokenType.COPY: 'COPY'>, 'CREATE': <TokenType.CREATE: 'CREATE'>, 'CROSS': <TokenType.CROSS: 'CROSS'>, 'CUBE': <TokenType.CUBE: 'CUBE'>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, 'CURRENT_USER': <TokenType.CURRENT_USER: 'CURRENT_USER'>, 'DATABASE': <TokenType.DATABASE: 'DATABASE'>, 'DEFAULT': <TokenType.DEFAULT: 'DEFAULT'>, 'DELETE': <TokenType.DELETE: 'DELETE'>, 'DESC': <TokenType.DESC: 'DESC'>, 'DESCRIBE': <TokenType.DESCRIBE: 'DESCRIBE'>, 'DISTINCT': <TokenType.DISTINCT: 'DISTINCT'>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>, 'DIV': <TokenType.DIV: 'DIV'>, 'DROP': <TokenType.DROP: 'DROP'>, 'ELSE': <TokenType.ELSE: 'ELSE'>, 'END': <TokenType.END: 'END'>, 'ENUM': <TokenType.ENUM: 'ENUM'>, 'ESCAPE': <TokenType.ESCAPE: 'ESCAPE'>, 'EXCEPT': <TokenType.EXCEPT: 'EXCEPT'>, 'EXECUTE': <TokenType.EXECUTE: 'EXECUTE'>, 'EXISTS': <TokenType.EXISTS: 'EXISTS'>, 'FALSE': <TokenType.FALSE: 'FALSE'>, 'FETCH': <TokenType.FETCH: 'FETCH'>, 'FILTER': <TokenType.FILTER: 'FILTER'>, 'FIRST': <TokenType.FIRST: 'FIRST'>, 'FULL': <TokenType.FULL: 'FULL'>, 'FUNCTION': <TokenType.FUNCTION: 'FUNCTION'>, 'FOR': <TokenType.FOR: 'FOR'>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, 'FORMAT': <TokenType.FORMAT: 'FORMAT'>, 'FROM': <TokenType.FROM: 'FROM'>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, 'GEOMETRY': <TokenType.GEOMETRY: 'GEOMETRY'>, 'GLOB': <TokenType.GLOB: 'GLOB'>, 'GROUP BY': <TokenType.GROUP_BY: 'GROUP_BY'>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 'GROUPING_SETS'>, 'HAVING': <TokenType.HAVING: 'HAVING'>, 'ILIKE': <TokenType.ILIKE: 'ILIKE'>, 'IN': <TokenType.IN: 'IN'>, 'INDEX': <TokenType.INDEX: 'INDEX'>, 'INET': <TokenType.INET: 'INET'>, 'INNER': <TokenType.INNER: 'INNER'>, 'INSERT': <TokenType.INSERT: 'INSERT'>, 'INTERVAL': <TokenType.INTERVAL: 'INTERVAL'>, 'INTERSECT': <TokenType.INTERSECT: 'INTERSECT'>, 'INTO': <TokenType.INTO: 'INTO'>, 'IS': <TokenType.IS: 'IS'>, 'ISNULL': <TokenType.ISNULL: 'ISNULL'>, 'JOIN': <TokenType.JOIN: 'JOIN'>, 'KEEP': <TokenType.KEEP: 'KEEP'>, 'KILL': <TokenType.KILL: 'KILL'>, 'LATERAL': <TokenType.LATERAL: 'LATERAL'>, 'LEFT': <TokenType.LEFT: 'LEFT'>, 'LIKE': <TokenType.LIKE: 'LIKE'>, 'LIMIT': <TokenType.LIMIT: 'LIMIT'>, 'LOAD': <TokenType.LOAD: 'LOAD'>, 'LOCK': <TokenType.LOCK: 'LOCK'>, 'MERGE': <TokenType.MERGE: 'MERGE'>, 'NAMESPACE': <TokenType.NAMESPACE: 'NAMESPACE'>, 'NATURAL': <TokenType.NATURAL: 'NATURAL'>, 'NEXT': <TokenType.NEXT: 'NEXT'>, 'NOT': <TokenType.NOT: 'NOT'>, 'NOTNULL': <TokenType.NOTNULL: 'NOTNULL'>, 'NULL': <TokenType.NULL: 'NULL'>, 'OBJECT': <TokenType.OBJECT: 'OBJECT'>, 'OFFSET': <TokenType.OFFSET: 'OFFSET'>, 'ON': <TokenType.ON: 'ON'>, 'OR': <TokenType.OR: 'OR'>, 'XOR': <TokenType.XOR: 'XOR'>, 'ORDER BY': <TokenType.ORDER_BY: 'ORDER_BY'>, 'ORDINALITY': <TokenType.ORDINALITY: 'ORDINALITY'>, 'OUTER': <TokenType.OUTER: 'OUTER'>, 'OVER': <TokenType.OVER: 'OVER'>, 'OVERLAPS': <TokenType.OVERLAPS: 'OVERLAPS'>, 'OVERWRITE': <TokenType.OVERWRITE: 'OVERWRITE'>, 'PARTITION': <TokenType.PARTITION: 'PARTITION'>, 'PARTITION BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PERCENT': <TokenType.PERCENT: 'PERCENT'>, 'PIVOT': <TokenType.PIVOT: 'PIVOT'>, 'PRAGMA': <TokenType.PRAGMA: 'PRAGMA'>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, 'PROCEDURE': <TokenType.PROCEDURE: 'PROCEDURE'>, 'QUALIFY': <TokenType.QUALIFY: 'QUALIFY'>, 'RANGE': <TokenType.RANGE: 'RANGE'>, 'RECURSIVE': <TokenType.RECURSIVE: 'RECURSIVE'>, 'REGEXP': <TokenType.RLIKE: 'RLIKE'>, 'RENAME': <TokenType.RENAME: 'RENAME'>, 'REPLACE': <TokenType.REPLACE: 'REPLACE'>, 'RETURNING': <TokenType.RETURNING: 'RETURNING'>, 'REFERENCES': <TokenType.REFERENCES: 'REFERENCES'>, 'RIGHT': <TokenType.RIGHT: 'RIGHT'>, 'RLIKE': <TokenType.RLIKE: 'RLIKE'>, 'ROLLBACK': <TokenType.ROLLBACK: 'ROLLBACK'>, 'ROLLUP': <TokenType.ROLLUP: 'ROLLUP'>, 'ROW': <TokenType.ROW: 'ROW'>, 'ROWS': <TokenType.ROWS: 'ROWS'>, 'SCHEMA': <TokenType.SCHEMA: 'SCHEMA'>, 'SELECT': <TokenType.SELECT: 'SELECT'>, 'SEMI': <TokenType.SEMI: 'SEMI'>, 'SET': <TokenType.SET: 'SET'>, 'SETTINGS': <TokenType.SETTINGS: 'SETTINGS'>, 'SHOW': <TokenType.SHOW: 'SHOW'>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 'SIMILAR_TO'>, 'SOME': <TokenType.SOME: 'SOME'>, 'SORT BY': <TokenType.SORT_BY: 'SORT_BY'>, 'START WITH': <TokenType.START_WITH: 'START_WITH'>, 'STRAIGHT_JOIN': <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, 'TABLE': <TokenType.TABLE: 'TABLE'>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>, 'TEMP': <TokenType.TEMPORARY: 'TEMPORARY'>, 'TEMPORARY': <TokenType.TEMPORARY: 'TEMPORARY'>, 'THEN': <TokenType.THEN: 'THEN'>, 'TRUE': <TokenType.TRUE: 'TRUE'>, 'TRUNCATE': <TokenType.TRUNCATE: 'TRUNCATE'>, 'UNION': <TokenType.UNION: 'UNION'>, 'UNKNOWN': <TokenType.UNKNOWN: 'UNKNOWN'>, 'UNNEST': <TokenType.UNNEST: 'UNNEST'>, 'UNPIVOT': <TokenType.UNPIVOT: 'UNPIVOT'>, 'UPDATE': <TokenType.UPDATE: 'UPDATE'>, 'USE': <TokenType.USE: 'USE'>, 'USING': <TokenType.USING: 'USING'>, 'UUID': <TokenType.UUID: 'UUID'>, 'VALUES': <TokenType.VALUES: 'VALUES'>, 'VIEW': <TokenType.VIEW: 'VIEW'>, 'VOLATILE': <TokenType.VOLATILE: 'VOLATILE'>, 'WHEN': <TokenType.WHEN: 'WHEN'>, 'WHERE': <TokenType.WHERE: 'WHERE'>, 'WINDOW': <TokenType.WINDOW: 'WINDOW'>, 'WITH': <TokenType.WITH: 'WITH'>, 'APPLY': <TokenType.APPLY: 'APPLY'>, 'ARRAY': <TokenType.ARRAY: 'ARRAY'>, 'BIT': <TokenType.BIT: 'BIT'>, 'BOOL': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BOOLEAN': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BYTE': <TokenType.TINYINT: 'TINYINT'>, 'MEDIUMINT': <TokenType.MEDIUMINT: 'MEDIUMINT'>, 'INT1': <TokenType.TINYINT: 'TINYINT'>, 'TINYINT': <TokenType.TINYINT: 'TINYINT'>, 'INT16': <TokenType.SMALLINT: 'SMALLINT'>, 'SHORT': <TokenType.SMALLINT: 'SMALLINT'>, 'SMALLINT': <TokenType.SMALLINT: 'SMALLINT'>, 'INT128': <TokenType.INT128: 'INT128'>, 'HUGEINT': <TokenType.INT128: 'INT128'>, 'UHUGEINT': <TokenType.UINT128: 'UINT128'>, 'INT2': <TokenType.SMALLINT: 'SMALLINT'>, 'INTEGER': <TokenType.INT: 'INT'>, 'INT': <TokenType.INT: 'INT'>, 'INT4': <TokenType.INT: 'INT'>, 'INT32': <TokenType.INT: 'INT'>, 'INT64': <TokenType.BIGINT: 'BIGINT'>, 'LONG': <TokenType.BIGINT: 'BIGINT'>, 'BIGINT': <TokenType.BIGINT: 'BIGINT'>, 'INT8': <TokenType.TINYINT: 'TINYINT'>, 'UINT': <TokenType.UINT: 'UINT'>, 'DEC': <TokenType.DECIMAL: 'DECIMAL'>, 'DECIMAL': <TokenType.DECIMAL: 'DECIMAL'>, 'DECIMAL32': <TokenType.DECIMAL32: 'DECIMAL32'>, 'DECIMAL64': <TokenType.DECIMAL64: 'DECIMAL64'>, 'DECIMAL128': <TokenType.DECIMAL128: 'DECIMAL128'>, 'DECIMAL256': <TokenType.DECIMAL256: 'DECIMAL256'>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'LIST': <TokenType.LIST: 'LIST'>, 'MAP': <TokenType.MAP: 'MAP'>, 'NULLABLE': <TokenType.NULLABLE: 'NULLABLE'>, 'NUMBER': <TokenType.DECIMAL: 'DECIMAL'>, 'NUMERIC': <TokenType.DECIMAL: 'DECIMAL'>, 'FIXED': <TokenType.DECIMAL: 'DECIMAL'>, 'REAL': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT4': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT8': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 'DOUBLE'>, 'JSON': <TokenType.JSON: 'JSON'>, 'JSONB': <TokenType.JSONB: 'JSONB'>, 'CHAR': <TokenType.CHAR: 'CHAR'>, 'CHARACTER': <TokenType.CHAR: 'CHAR'>, 'NCHAR': <TokenType.NCHAR: 'NCHAR'>, 'VARCHAR': <TokenType.VARCHAR: 'VARCHAR'>, 'VARCHAR2': <TokenType.VARCHAR: 'VARCHAR'>, 'NVARCHAR': <TokenType.NVARCHAR: 'NVARCHAR'>, 'NVARCHAR2': <TokenType.NVARCHAR: 'NVARCHAR'>, 'BPCHAR': <TokenType.BPCHAR: 'BPCHAR'>, 'STR': <TokenType.TEXT: 'TEXT'>, 'STRING': <TokenType.TEXT: 'TEXT'>, 'TEXT': <TokenType.TEXT: 'TEXT'>, 'LONGTEXT': <TokenType.LONGTEXT: 'LONGTEXT'>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, 'TINYTEXT': <TokenType.TINYTEXT: 'TINYTEXT'>, 'CLOB': <TokenType.TEXT: 'TEXT'>, 'LONGVARCHAR': <TokenType.TEXT: 'TEXT'>, 'BINARY': <TokenType.BINARY: 'BINARY'>, 'BLOB': <TokenType.VARBINARY: 'VARBINARY'>, 'LONGBLOB': <TokenType.LONGBLOB: 'LONGBLOB'>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, 'TINYBLOB': <TokenType.TINYBLOB: 'TINYBLOB'>, 'BYTEA': <TokenType.VARBINARY: 'VARBINARY'>, 'VARBINARY': <TokenType.VARBINARY: 'VARBINARY'>, 'TIME': <TokenType.TIME: 'TIME'>, 'TIMETZ': <TokenType.TIMETZ: 'TIMETZ'>, 'TIMESTAMP': <TokenType.TIMESTAMP: 'TIMESTAMP'>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMP_LTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMPNTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'TIMESTAMP_NTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'DATE': <TokenType.DATE: 'DATE'>, 'DATETIME': <TokenType.DATETIME: 'DATETIME'>, 'INT4RANGE': <TokenType.INT4RANGE: 'INT4RANGE'>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, 'INT8RANGE': <TokenType.INT8RANGE: 'INT8RANGE'>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, 'NUMRANGE': <TokenType.NUMRANGE: 'NUMRANGE'>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, 'TSRANGE': <TokenType.TSRANGE: 'TSRANGE'>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, 'TSTZRANGE': <TokenType.TSTZRANGE: 'TSTZRANGE'>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, 'DATERANGE': <TokenType.DATERANGE: 'DATERANGE'>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, 'UNIQUE': <TokenType.UNIQUE: 'UNIQUE'>, 'VECTOR': <TokenType.VECTOR: 'VECTOR'>, 'STRUCT': <TokenType.STRUCT: 'STRUCT'>, 'SEQUENCE': <TokenType.SEQUENCE: 'SEQUENCE'>, 'VARIANT': <TokenType.VARIANT: 'VARIANT'>, 'ALTER': <TokenType.ALTER: 'ALTER'>, 'ANALYZE': <TokenType.ANALYZE: 'ANALYZE'>, 'CALL': <TokenType.COMMAND: 'COMMAND'>, 'COMMENT': <TokenType.COMMENT: 'COMMENT'>, 'EXPLAIN': <TokenType.COMMAND: 'COMMAND'>, 'GRANT': <TokenType.GRANT: 'GRANT'>, 'OPTIMIZE': <TokenType.COMMAND: 'COMMAND'>, 'PREPARE': <TokenType.COMMAND: 'COMMAND'>, 'VACUUM': <TokenType.COMMAND: 'COMMAND'>, 'USER-DEFINED': <TokenType.USERDEFINED: 'USERDEFINED'>, 'FOR VERSION': <TokenType.VERSION_SNAPSHOT: 'VERSION_SNAPSHOT'>, 'FOR TIMESTAMP': <TokenType.TIMESTAMP_SNAPSHOT: 'TIMESTAMP_SNAPSHOT'>, 'ADD ARCHIVE': <TokenType.COMMAND: 'COMMAND'>, 'ADD ARCHIVES': <TokenType.COMMAND: 'COMMAND'>, 'ADD FILE': <TokenType.COMMAND: 'COMMAND'>, 'ADD FILES': <TokenType.COMMAND: 'COMMAND'>, 'ADD JAR': <TokenType.COMMAND: 'COMMAND'>, 'ADD JARS': <TokenType.COMMAND: 'COMMAND'>, 'MINUS': <TokenType.EXCEPT: 'EXCEPT'>, 'MSCK REPAIR': <TokenType.COMMAND: 'COMMAND'>, 'REFRESH': <TokenType.REFRESH: 'REFRESH'>, 'TIMESTAMP AS OF': <TokenType.TIMESTAMP_SNAPSHOT: 'TIMESTAMP_SNAPSHOT'>, 'VERSION AS OF': <TokenType.VERSION_SNAPSHOT: 'VERSION_SNAPSHOT'>, 'SERDEPROPERTIES': <TokenType.SERDE_PROPERTIES: 'SERDE_PROPERTIES'>}
NUMERIC_LITERALS = {'L': 'BIGINT', 'S': 'SMALLINT', 'Y': 'TINYINT', 'D': 'DOUBLE', 'F': 'FLOAT', 'BD': 'DECIMAL'}
class Hive.Parser(sqlglot.parser.Parser):
272    class Parser(parser.Parser):
273        LOG_DEFAULTS_TO_LN = True
274        STRICT_CAST = False
275        VALUES_FOLLOWED_BY_PAREN = False
276
277        FUNCTIONS = {
278            **parser.Parser.FUNCTIONS,
279            "ASCII": exp.Unicode.from_arg_list,
280            "BASE64": exp.ToBase64.from_arg_list,
281            "COLLECT_LIST": lambda args: exp.ArrayAgg(this=seq_get(args, 0), nulls_excluded=True),
282            "COLLECT_SET": exp.ArrayUniqueAgg.from_arg_list,
283            "DATE_ADD": lambda args: exp.TsOrDsAdd(
284                this=seq_get(args, 0), expression=seq_get(args, 1), unit=exp.Literal.string("DAY")
285            ),
286            "DATE_FORMAT": lambda args: build_formatted_time(exp.TimeToStr, "hive")(
287                [
288                    exp.TimeStrToTime(this=seq_get(args, 0)),
289                    seq_get(args, 1),
290                ]
291            ),
292            "DATE_SUB": lambda args: exp.TsOrDsAdd(
293                this=seq_get(args, 0),
294                expression=exp.Mul(this=seq_get(args, 1), expression=exp.Literal.number(-1)),
295                unit=exp.Literal.string("DAY"),
296            ),
297            "DATEDIFF": lambda args: exp.DateDiff(
298                this=exp.TsOrDsToDate(this=seq_get(args, 0)),
299                expression=exp.TsOrDsToDate(this=seq_get(args, 1)),
300            ),
301            "DAY": lambda args: exp.Day(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
302            "FIRST": _build_with_ignore_nulls(exp.First),
303            "FIRST_VALUE": _build_with_ignore_nulls(exp.FirstValue),
304            "FROM_UNIXTIME": build_formatted_time(exp.UnixToStr, "hive", True),
305            "GET_JSON_OBJECT": exp.JSONExtractScalar.from_arg_list,
306            "LAST": _build_with_ignore_nulls(exp.Last),
307            "LAST_VALUE": _build_with_ignore_nulls(exp.LastValue),
308            "MAP": parser.build_var_map,
309            "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate.from_arg_list(args)),
310            "PERCENTILE": exp.Quantile.from_arg_list,
311            "PERCENTILE_APPROX": exp.ApproxQuantile.from_arg_list,
312            "REGEXP_EXTRACT": build_regexp_extract(exp.RegexpExtract),
313            "REGEXP_EXTRACT_ALL": build_regexp_extract(exp.RegexpExtractAll),
314            "SEQUENCE": exp.GenerateSeries.from_arg_list,
315            "SIZE": exp.ArraySize.from_arg_list,
316            "SPLIT": exp.RegexpSplit.from_arg_list,
317            "STR_TO_MAP": lambda args: exp.StrToMap(
318                this=seq_get(args, 0),
319                pair_delim=seq_get(args, 1) or exp.Literal.string(","),
320                key_value_delim=seq_get(args, 2) or exp.Literal.string(":"),
321            ),
322            "TO_DATE": build_formatted_time(exp.TsOrDsToDate, "hive"),
323            "TO_JSON": exp.JSONFormat.from_arg_list,
324            "TRUNC": exp.TimestampTrunc.from_arg_list,
325            "UNBASE64": exp.FromBase64.from_arg_list,
326            "UNIX_TIMESTAMP": lambda args: build_formatted_time(exp.StrToUnix, "hive", True)(
327                args or [exp.CurrentTimestamp()]
328            ),
329            "YEAR": lambda args: exp.Year(this=exp.TsOrDsToDate.from_arg_list(args)),
330        }
331
332        NO_PAREN_FUNCTION_PARSERS = {
333            **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
334            "TRANSFORM": lambda self: self._parse_transform(),
335        }
336
337        NO_PAREN_FUNCTIONS = parser.Parser.NO_PAREN_FUNCTIONS.copy()
338        NO_PAREN_FUNCTIONS.pop(TokenType.CURRENT_TIME)
339
340        PROPERTY_PARSERS = {
341            **parser.Parser.PROPERTY_PARSERS,
342            "SERDEPROPERTIES": lambda self: exp.SerdeProperties(
343                expressions=self._parse_wrapped_csv(self._parse_property)
344            ),
345        }
346
347        def _parse_transform(self) -> t.Optional[exp.Transform | exp.QueryTransform]:
348            if not self._match(TokenType.L_PAREN, advance=False):
349                self._retreat(self._index - 1)
350                return None
351
352            args = self._parse_wrapped_csv(self._parse_lambda)
353            row_format_before = self._parse_row_format(match_row=True)
354
355            record_writer = None
356            if self._match_text_seq("RECORDWRITER"):
357                record_writer = self._parse_string()
358
359            if not self._match(TokenType.USING):
360                return exp.Transform.from_arg_list(args)
361
362            command_script = self._parse_string()
363
364            self._match(TokenType.ALIAS)
365            schema = self._parse_schema()
366
367            row_format_after = self._parse_row_format(match_row=True)
368            record_reader = None
369            if self._match_text_seq("RECORDREADER"):
370                record_reader = self._parse_string()
371
372            return self.expression(
373                exp.QueryTransform,
374                expressions=args,
375                command_script=command_script,
376                schema=schema,
377                row_format_before=row_format_before,
378                record_writer=record_writer,
379                row_format_after=row_format_after,
380                record_reader=record_reader,
381            )
382
383        def _parse_types(
384            self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
385        ) -> t.Optional[exp.Expression]:
386            """
387            Spark (and most likely Hive) treats casts to CHAR(length) and VARCHAR(length) as casts to
388            STRING in all contexts except for schema definitions. For example, this is in Spark v3.4.0:
389
390                spark-sql (default)> select cast(1234 as varchar(2));
391                23/06/06 15:51:18 WARN CharVarcharUtils: The Spark cast operator does not support
392                char/varchar type and simply treats them as string type. Please use string type
393                directly to avoid confusion. Otherwise, you can set spark.sql.legacy.charVarcharAsString
394                to true, so that Spark treat them as string type as same as Spark 3.0 and earlier
395
396                1234
397                Time taken: 4.265 seconds, Fetched 1 row(s)
398
399            This shows that Spark doesn't truncate the value into '12', which is inconsistent with
400            what other dialects (e.g. postgres) do, so we need to drop the length to transpile correctly.
401
402            Reference: https://spark.apache.org/docs/latest/sql-ref-datatypes.html
403            """
404            this = super()._parse_types(
405                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
406            )
407
408            if this and not schema:
409                return this.transform(
410                    lambda node: (
411                        node.replace(exp.DataType.build("text"))
412                        if isinstance(node, exp.DataType) and node.is_type("char", "varchar")
413                        else node
414                    ),
415                    copy=False,
416                )
417
418            return this
419
420        def _parse_partition_and_order(
421            self,
422        ) -> t.Tuple[t.List[exp.Expression], t.Optional[exp.Expression]]:
423            return (
424                (
425                    self._parse_csv(self._parse_assignment)
426                    if self._match_set({TokenType.PARTITION_BY, TokenType.DISTRIBUTE_BY})
427                    else []
428                ),
429                super()._parse_order(skip_order_token=self._match(TokenType.SORT_BY)),
430            )
431
432        def _parse_parameter(self) -> exp.Parameter:
433            self._match(TokenType.L_BRACE)
434            this = self._parse_identifier() or self._parse_primary_or_var()
435            expression = self._match(TokenType.COLON) and (
436                self._parse_identifier() or self._parse_primary_or_var()
437            )
438            self._match(TokenType.R_BRACE)
439            return self.expression(exp.Parameter, this=this, expression=expression)
440
441        def _to_prop_eq(self, expression: exp.Expression, index: int) -> exp.Expression:
442            if isinstance(expression, exp.Column):
443                key = expression.this
444            else:
445                key = exp.to_identifier(f"col{index + 1}")
446
447            return self.expression(exp.PropertyEQ, this=key, expression=expression)

Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.

Arguments:
  • error_level: The desired error level. Default: ErrorLevel.IMMEDIATE
  • error_message_context: The amount of context to capture from a query string when displaying the error message (in number of characters). Default: 100
  • max_errors: Maximum number of error messages to include in a raised ParseError. This is only relevant if error_level is ErrorLevel.RAISE. Default: 3
LOG_DEFAULTS_TO_LN = True
STRICT_CAST = False
VALUES_FOLLOWED_BY_PAREN = False
FUNCTIONS = {'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Abs'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AddMonths'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'APPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Apply'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxQuantile'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxTopK'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARRAY': <function Parser.<lambda>>, 'ARRAY_AGG': <function Parser.<lambda>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAny'>>, 'ARRAY_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CONSTRUCT_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConstructCompact'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'ARRAY_HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'ARRAY_CONTAINS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContainsAll'>>, 'ARRAY_HAS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContainsAll'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayOverlaps'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySort'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySum'>>, 'ARRAY_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUniqueAgg'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Avg'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CHR': <function Parser.<lambda>>, 'CHAR': <function Parser.<lambda>>, 'COALESCE': <function build_coalesce>, 'IFNULL': <function build_coalesce>, 'NVL': <function build_coalesce>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Collate'>>, 'COLUMNS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Columns'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedParameterizedAgg'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ConnectByRoot'>>, 'CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Contains'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Convert'>>, 'CONVERT_TIMEZONE': <function build_convert_timezone>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Corr'>>, 'COUNT': <function Parser.<lambda>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COUNTIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COVAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarPop'>>, 'COVAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarSamp'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDatetime'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestamp'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentUser'>>, 'DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Date'>>, 'DATE_ADD': <function Hive.Parser.<lambda>>, 'DATEDIFF': <function Hive.Parser.<lambda>>, 'DATE_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateDiff'>>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateStrToDate'>>, 'DATE_SUB': <function Hive.Parser.<lambda>>, 'DATE_TO_DATE_STR': <function Parser.<lambda>>, 'DATE_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateToDi'>>, 'DATE_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateTrunc'>>, 'DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Datetime'>>, 'DATETIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeAdd'>>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeDiff'>>, 'DATETIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeSub'>>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeTrunc'>>, 'DAY': <function Hive.Parser.<lambda>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAYOFMONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeekIso'>>, 'ISODOW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeekIso'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Decode'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DiToDate'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Encode'>>, 'EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exists'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Explode'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodeOuter'>>, 'EXPLODING_GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodingGenerateSeries'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Extract'>>, 'FEATURES_AT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FeaturesAtTime'>>, 'FIRST': <function _build_with_ignore_nulls.<locals>._parse>, 'FIRST_VALUE': <function _build_with_ignore_nulls.<locals>._parse>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Flatten'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Floor'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase64'>>, 'FROM_ISO8601_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromISO8601Timestamp'>>, 'GAP_FILL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GapFill'>>, 'GENERATE_DATE_ARRAY': <function Parser.<lambda>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'GENERATE_TIMESTAMP_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateTimestampArray'>>, 'GREATEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Greatest'>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GroupConcat'>>, 'HEX': <function build_hex>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hll'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Initcap'>>, 'INLINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Inline'>>, 'INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Int64'>>, 'IS_ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsAscii'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayAgg'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayContains'>>, 'JSONB_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBContains'>>, 'JSONB_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExists'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtractScalar'>>, 'J_S_O_N_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONExists'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONExtractArray'>>, 'JSON_EXTRACT_SCALAR': <function build_extract_json_with_path.<locals>._builder>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObjectAgg'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONTable'>>, 'J_S_O_N_VALUE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONValueArray'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lag'>>, 'LAST': <function _build_with_ignore_nulls.<locals>._parse>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_VALUE': <function _build_with_ignore_nulls.<locals>._parse>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lead'>>, 'LEAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Least'>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Left'>>, 'LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'CHAR_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'CHARACTER_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Levenshtein'>>, 'LIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.List'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ln'>>, 'LOG': <function build_logarithm>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'LOWER': <function build_lower>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'LOWER_HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LowerHex'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5Digest'>>, 'MAKE_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MakeInterval'>>, 'MAP': <function build_var_map>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MapFromEntries'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Max'>>, 'MEDIAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Median'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Min'>>, 'MONTH': <function Hive.Parser.<lambda>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MonthsBetween'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NextValueFor'>>, 'NORMALIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Normalize'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NthValue'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nvl2'>>, 'OBJECT_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ObjectInsert'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.OpenJSON'>>, 'OVERLAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Overlay'>>, 'PAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pad'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParameterizedAgg'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileDisc'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Predict'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quantile'>>, 'QUARTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quarter'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Randn'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RangeN'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ReadCSV'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Reduce'>>, 'REGEXP_EXTRACT': <function build_regexp_extract.<locals>._builder>, 'REGEXP_EXTRACT_ALL': <function build_regexp_extract.<locals>._builder>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpILike'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpSplit'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Repeat'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Right'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RowNumber'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA2'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeDivide'>>, 'SIGN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SIGNUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SortArray'>>, 'SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpSplit'>>, 'SPLIT_PART': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SplitPart'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sqrt'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToDate'>>, 'STR_TO_MAP': <function Hive.Parser.<lambda>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToUnix'>>, 'STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.String'>>, 'STRING_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StringToArray'>>, 'SPLIT_BY_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StringToArray'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Substring'>>, 'SUBSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Substring'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sum'>>, 'TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Time'>>, 'TIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeAdd'>>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIMEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToUnix'>>, 'TIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeSub'>>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeTrunc'>>, 'TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Timestamp'>>, 'TIMESTAMP_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampAdd'>>, 'TIMESTAMPDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMP_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampSub'>>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampTrunc'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToArray'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToBase64'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToChar'>>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDays'>>, 'TO_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDouble'>>, 'TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToMap'>>, 'TO_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToNumber'>>, 'TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Transform'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Trim'>>, 'TRY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Try'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TryCast'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDatetime'>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTime'>>, 'TS_OR_DS_TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTimestamp'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unhex'>>, 'UNICODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unicode'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixDate'>>, 'UNIX_SECONDS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixSeconds'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTimeStr'>>, 'UNNEST': <function Parser.<lambda>>, 'UPPER': <function build_upper>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'GEN_RANDOM_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'GENERATE_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'UUID_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'VAR_MAP': <function build_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Week'>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'XMLELEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLElement'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLTable'>>, 'XOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Xor'>>, 'YEAR': <function Hive.Parser.<lambda>>, 'ARRAYAGG': <function Parser.<lambda>>, 'GLOB': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function build_extract_json_with_path.<locals>._builder>, 'LIKE': <function build_like>, 'LOG2': <function Parser.<lambda>>, 'LOG10': <function Parser.<lambda>>, 'LPAD': <function Parser.<lambda>>, 'LEFTPAD': <function Parser.<lambda>>, 'LTRIM': <function Parser.<lambda>>, 'MOD': <function build_mod>, 'RIGHTPAD': <function Parser.<lambda>>, 'RPAD': <function Parser.<lambda>>, 'RTRIM': <function Parser.<lambda>>, 'SCOPE_RESOLUTION': <function Parser.<lambda>>, 'STRPOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'CHARINDEX': <function Parser.<lambda>>, 'INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'LOCATE': <function Parser.<lambda>>, 'TO_HEX': <function build_hex>, 'ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unicode'>>, 'BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToBase64'>>, 'COLLECT_LIST': <function Hive.Parser.<lambda>>, 'COLLECT_SET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUniqueAgg'>>, 'DATE_FORMAT': <function Hive.Parser.<lambda>>, 'FROM_UNIXTIME': <function build_formatted_time.<locals>._builder>, 'GET_JSON_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONExtractScalar'>>, 'PERCENTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quantile'>>, 'PERCENTILE_APPROX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxQuantile'>>, 'SEQUENCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'TO_DATE': <function build_formatted_time.<locals>._builder>, 'TO_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>, 'TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampTrunc'>>, 'UNBASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase64'>>, 'UNIX_TIMESTAMP': <function Hive.Parser.<lambda>>}
NO_PAREN_FUNCTION_PARSERS = {'ANY': <function Parser.<lambda>>, 'CASE': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <function Parser.<lambda>>, 'IF': <function Parser.<lambda>>, 'TRANSFORM': <function Hive.Parser.<lambda>>}
NO_PAREN_FUNCTIONS = {<TokenType.CURRENT_DATE: 'CURRENT_DATE'>: <class 'sqlglot.expressions.CurrentDate'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>: <class 'sqlglot.expressions.CurrentDate'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>: <class 'sqlglot.expressions.CurrentTimestamp'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>: <class 'sqlglot.expressions.CurrentUser'>}
PROPERTY_PARSERS = {'ALLOWED_VALUES': <function Parser.<lambda>>, 'ALGORITHM': <function Parser.<lambda>>, 'AUTO': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'BACKUP': <function Parser.<lambda>>, 'BLOCKCOMPRESSION': <function Parser.<lambda>>, 'CHARSET': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECKSUM': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'CONTAINS': <function Parser.<lambda>>, 'COPY': <function Parser.<lambda>>, 'DATABLOCKSIZE': <function Parser.<lambda>>, 'DATA_DELETION': <function Parser.<lambda>>, 'DEFINER': <function Parser.<lambda>>, 'DETERMINISTIC': <function Parser.<lambda>>, 'DISTRIBUTED': <function Parser.<lambda>>, 'DUPLICATE': <function Parser.<lambda>>, 'DYNAMIC': <function Parser.<lambda>>, 'DISTKEY': <function Parser.<lambda>>, 'DISTSTYLE': <function Parser.<lambda>>, 'EMPTY': <function Parser.<lambda>>, 'ENGINE': <function Parser.<lambda>>, 'EXECUTE': <function Parser.<lambda>>, 'EXTERNAL': <function Parser.<lambda>>, 'FALLBACK': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'FREESPACE': <function Parser.<lambda>>, 'GLOBAL': <function Parser.<lambda>>, 'HEAP': <function Parser.<lambda>>, 'ICEBERG': <function Parser.<lambda>>, 'IMMUTABLE': <function Parser.<lambda>>, 'INHERITS': <function Parser.<lambda>>, 'INPUT': <function Parser.<lambda>>, 'JOURNAL': <function Parser.<lambda>>, 'LANGUAGE': <function Parser.<lambda>>, 'LAYOUT': <function Parser.<lambda>>, 'LIFETIME': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'LOCATION': <function Parser.<lambda>>, 'LOCK': <function Parser.<lambda>>, 'LOCKING': <function Parser.<lambda>>, 'LOG': <function Parser.<lambda>>, 'MATERIALIZED': <function Parser.<lambda>>, 'MERGEBLOCKRATIO': <function Parser.<lambda>>, 'MODIFIES': <function Parser.<lambda>>, 'MULTISET': <function Parser.<lambda>>, 'NO': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'ORDER BY': <function Parser.<lambda>>, 'OUTPUT': <function Parser.<lambda>>, 'PARTITION': <function Parser.<lambda>>, 'PARTITION BY': <function Parser.<lambda>>, 'PARTITIONED BY': <function Parser.<lambda>>, 'PARTITIONED_BY': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'RANGE': <function Parser.<lambda>>, 'READS': <function Parser.<lambda>>, 'REMOTE': <function Parser.<lambda>>, 'RETURNS': <function Parser.<lambda>>, 'STRICT': <function Parser.<lambda>>, 'STREAMING': <function Parser.<lambda>>, 'ROW': <function Parser.<lambda>>, 'ROW_FORMAT': <function Parser.<lambda>>, 'SAMPLE': <function Parser.<lambda>>, 'SECURE': <function Parser.<lambda>>, 'SECURITY': <function Parser.<lambda>>, 'SET': <function Parser.<lambda>>, 'SETTINGS': <function Parser.<lambda>>, 'SHARING': <function Parser.<lambda>>, 'SORTKEY': <function Parser.<lambda>>, 'SOURCE': <function Parser.<lambda>>, 'STABLE': <function Parser.<lambda>>, 'STORED': <function Parser.<lambda>>, 'SYSTEM_VERSIONING': <function Parser.<lambda>>, 'TBLPROPERTIES': <function Parser.<lambda>>, 'TEMP': <function Parser.<lambda>>, 'TEMPORARY': <function Parser.<lambda>>, 'TO': <function Parser.<lambda>>, 'TRANSIENT': <function Parser.<lambda>>, 'TRANSFORM': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'USING': <function Parser.<lambda>>, 'UNLOGGED': <function Parser.<lambda>>, 'VOLATILE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>, 'SERDEPROPERTIES': <function Hive.Parser.<lambda>>}
ID_VAR_TOKENS = {<TokenType.NEXT: 'NEXT'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.ROW: 'ROW'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.POINT: 'POINT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.CASE: 'CASE'>, <TokenType.TIME: 'TIME'>, <TokenType.LOAD: 'LOAD'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.JSONB: 'JSONB'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.SOURCE: 'SOURCE'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.ASC: 'ASC'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.MODEL: 'MODEL'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.SET: 'SET'>, <TokenType.VIEW: 'VIEW'>, <TokenType.INT: 'INT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.FULL: 'FULL'>, <TokenType.JSON: 'JSON'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.COPY: 'COPY'>, <TokenType.BINARY: 'BINARY'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.INT128: 'INT128'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TOP: 'TOP'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.DELETE: 'DELETE'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.LINESTRING: 'LINESTRING'>, <TokenType.UINT256: 'UINT256'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.RENAME: 'RENAME'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.NAME: 'NAME'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.MONEY: 'MONEY'>, <TokenType.DATE32: 'DATE32'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.ANY: 'ANY'>, <TokenType.RING: 'RING'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.DATE: 'DATE'>, <TokenType.NULL: 'NULL'>, <TokenType.LEFT: 'LEFT'>, <TokenType.FIRST: 'FIRST'>, <TokenType.KILL: 'KILL'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.LIMIT: 'LIMIT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.DIV: 'DIV'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.CUBE: 'CUBE'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.UINT: 'UINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.ROWS: 'ROWS'>, <TokenType.VAR: 'VAR'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.SOME: 'SOME'>, <TokenType.ANTI: 'ANTI'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.IPV4: 'IPV4'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.INET: 'INET'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.DATETIME2: 'DATETIME2'>, <TokenType.FALSE: 'FALSE'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.DETACH: 'DETACH'>, <TokenType.YEAR: 'YEAR'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.TABLE: 'TABLE'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.UINT128: 'UINT128'>, <TokenType.TEXT: 'TEXT'>, <TokenType.KEEP: 'KEEP'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.ATTACH: 'ATTACH'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TRUE: 'TRUE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.ASOF: 'ASOF'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.CHAR: 'CHAR'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.INDEX: 'INDEX'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.USE: 'USE'>, <TokenType.TAG: 'TAG'>, <TokenType.CACHE: 'CACHE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.SHOW: 'SHOW'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.SMALLDATETIME: 'SMALLDATETIME'>, <TokenType.DECIMAL256: 'DECIMAL256'>, <TokenType.LIST: 'LIST'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.APPLY: 'APPLY'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.NAMESPACE: 'NAMESPACE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DESC: 'DESC'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.END: 'END'>, <TokenType.XML: 'XML'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.FILTER: 'FILTER'>, <TokenType.SEMI: 'SEMI'>, <TokenType.IS: 'IS'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.DYNAMIC: 'DYNAMIC'>, <TokenType.POLYGON: 'POLYGON'>, <TokenType.NESTED: 'NESTED'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.BIT: 'BIT'>, <TokenType.INT256: 'INT256'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.FINAL: 'FINAL'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.SUPER: 'SUPER'>, <TokenType.SINK: 'SINK'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.RANGE: 'RANGE'>, <TokenType.ALL: 'ALL'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.MAP: 'MAP'>}
TABLE_ALIAS_TOKENS = {<TokenType.NEXT: 'NEXT'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.ROW: 'ROW'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.POINT: 'POINT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.CASE: 'CASE'>, <TokenType.TIME: 'TIME'>, <TokenType.LOAD: 'LOAD'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.JSONB: 'JSONB'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.SOURCE: 'SOURCE'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.ASC: 'ASC'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.MODEL: 'MODEL'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.SET: 'SET'>, <TokenType.VIEW: 'VIEW'>, <TokenType.INT: 'INT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.JSON: 'JSON'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.COPY: 'COPY'>, <TokenType.BINARY: 'BINARY'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.INT128: 'INT128'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TOP: 'TOP'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.DELETE: 'DELETE'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.LINESTRING: 'LINESTRING'>, <TokenType.UINT256: 'UINT256'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.RENAME: 'RENAME'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.NAME: 'NAME'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.MONEY: 'MONEY'>, <TokenType.DATE32: 'DATE32'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.ANY: 'ANY'>, <TokenType.RING: 'RING'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.DATE: 'DATE'>, <TokenType.NULL: 'NULL'>, <TokenType.FIRST: 'FIRST'>, <TokenType.KILL: 'KILL'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.LIMIT: 'LIMIT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.DIV: 'DIV'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.CUBE: 'CUBE'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.UINT: 'UINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.VAR: 'VAR'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.SOME: 'SOME'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.IPV4: 'IPV4'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.INET: 'INET'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.DATETIME2: 'DATETIME2'>, <TokenType.FALSE: 'FALSE'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.DETACH: 'DETACH'>, <TokenType.YEAR: 'YEAR'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.TABLE: 'TABLE'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.UINT128: 'UINT128'>, <TokenType.TEXT: 'TEXT'>, <TokenType.KEEP: 'KEEP'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.ATTACH: 'ATTACH'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TRUE: 'TRUE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.CHAR: 'CHAR'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.INDEX: 'INDEX'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.USE: 'USE'>, <TokenType.TAG: 'TAG'>, <TokenType.CACHE: 'CACHE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.SHOW: 'SHOW'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.SMALLDATETIME: 'SMALLDATETIME'>, <TokenType.DECIMAL256: 'DECIMAL256'>, <TokenType.LIST: 'LIST'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.NAMESPACE: 'NAMESPACE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DESC: 'DESC'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.END: 'END'>, <TokenType.XML: 'XML'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.FILTER: 'FILTER'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.IS: 'IS'>, <TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.DYNAMIC: 'DYNAMIC'>, <TokenType.POLYGON: 'POLYGON'>, <TokenType.NESTED: 'NESTED'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.BIT: 'BIT'>, <TokenType.INT256: 'INT256'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.FINAL: 'FINAL'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.SUPER: 'SUPER'>, <TokenType.SINK: 'SINK'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.RANGE: 'RANGE'>, <TokenType.ALL: 'ALL'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.ROWS: 'ROWS'>, <TokenType.MAP: 'MAP'>}
SHOW_TRIE: Dict = {}
SET_TRIE: Dict = {'GLOBAL': {0: True}, 'LOCAL': {0: True}, 'SESSION': {0: True}, 'TRANSACTION': {0: True}}
Inherited Members
sqlglot.parser.Parser
Parser
STRUCT_TYPE_TOKENS
NESTED_TYPE_TOKENS
ENUM_TYPE_TOKENS
AGGREGATE_TYPE_TOKENS
TYPE_TOKENS
SIGNED_TO_UNSIGNED_TYPE_TOKEN
SUBQUERY_PREDICATES
RESERVED_TOKENS
DB_CREATABLES
CREATABLES
ALTERABLES
INTERVAL_VARS
ALIAS_TOKENS
ARRAY_CONSTRUCTORS
COMMENT_TABLE_ALIAS_TOKENS
UPDATE_ALIAS_TOKENS
TRIM_TYPES
FUNC_TOKENS
CONJUNCTION
ASSIGNMENT
DISJUNCTION
EQUALITY
COMPARISON
BITWISE
TERM
FACTOR
EXPONENT
TIMES
TIMESTAMPS
SET_OPERATIONS
JOIN_METHODS
JOIN_SIDES
JOIN_KINDS
JOIN_HINTS
LAMBDAS
COLUMN_OPERATORS
EXPRESSION_PARSERS
STATEMENT_PARSERS
UNARY_PARSERS
STRING_PARSERS
NUMERIC_PARSERS
PRIMARY_PARSERS
PLACEHOLDER_PARSERS
RANGE_PARSERS
CONSTRAINT_PARSERS
ALTER_PARSERS
ALTER_ALTER_PARSERS
SCHEMA_UNNAMED_CONSTRAINTS
INVALID_FUNC_NAME_TOKENS
FUNCTIONS_WITH_ALIASED_ARGS
KEY_VALUE_DEFINITIONS
FUNCTION_PARSERS
QUERY_MODIFIER_PARSERS
SET_PARSERS
SHOW_PARSERS
TYPE_LITERAL_PARSERS
TYPE_CONVERTERS
DDL_SELECT_TOKENS
PRE_VOLATILE_TOKENS
TRANSACTION_KIND
TRANSACTION_CHARACTERISTICS
CONFLICT_ACTIONS
CREATE_SEQUENCE
ISOLATED_LOADING_OPTIONS
USABLES
CAST_ACTIONS
SCHEMA_BINDING_OPTIONS
PROCEDURE_OPTIONS
EXECUTE_AS_OPTIONS
KEY_CONSTRAINT_OPTIONS
INSERT_ALTERNATIVES
CLONE_KEYWORDS
HISTORICAL_DATA_PREFIX
HISTORICAL_DATA_KIND
OPCLASS_FOLLOW_KEYWORDS
OPTYPE_FOLLOW_TOKENS
TABLE_INDEX_HINT_TOKENS
VIEW_ATTRIBUTES
WINDOW_ALIAS_TOKENS
WINDOW_BEFORE_PAREN_TOKENS
WINDOW_SIDES
JSON_KEY_VALUE_SEPARATOR_TOKENS
FETCH_TOKENS
ADD_CONSTRAINT_TOKENS
DISTINCT_TOKENS
NULL_TOKENS
UNNEST_OFFSET_ALIAS_TOKENS
SELECT_START_TOKENS
COPY_INTO_VARLEN_OPTIONS
IS_JSON_PREDICATE_KIND
ODBC_DATETIME_LITERALS
ON_CONDITION_TOKENS
PRIVILEGE_FOLLOW_TOKENS
DESCRIBE_STYLES
ANALYZE_STYLES
ANALYZE_EXPRESSION_PARSERS
PARTITION_KEYWORDS
AMBIGUOUS_ALIAS_TOKENS
OPERATION_MODIFIERS
PREFIXED_PIVOT_COLUMNS
IDENTIFY_PIVOT_STRINGS
ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN
TABLESAMPLE_CSV
DEFAULT_SAMPLING_METHOD
SET_REQUIRES_ASSIGNMENT_DELIMITER
TRIM_PATTERN_FIRST
STRING_ALIASES
MODIFIERS_ATTACHED_TO_SET_OP
SET_OP_MODIFIERS
NO_PAREN_IF_COMMANDS
JSON_ARROWS_REQUIRE_JSON_TYPE
COLON_IS_VARIANT_EXTRACT
SUPPORTS_IMPLICIT_UNNEST
INTERVAL_SPANS
SUPPORTS_PARTITION_SELECTION
WRAPPED_TRANSFORM_COLUMN_CONSTRAINT
OPTIONAL_ALIAS_TOKEN_CTE
error_level
error_message_context
max_errors
dialect
reset
parse
parse_into
check_errors
raise_error
expression
validate_expression
errors
sql
class Hive.Generator(sqlglot.generator.Generator):
449    class Generator(generator.Generator):
450        LIMIT_FETCH = "LIMIT"
451        TABLESAMPLE_WITH_METHOD = False
452        JOIN_HINTS = False
453        TABLE_HINTS = False
454        QUERY_HINTS = False
455        INDEX_ON = "ON TABLE"
456        EXTRACT_ALLOWS_QUOTES = False
457        NVL2_SUPPORTED = False
458        LAST_DAY_SUPPORTS_DATE_PART = False
459        JSON_PATH_SINGLE_QUOTE_ESCAPE = True
460        SUPPORTS_TO_NUMBER = False
461        WITH_PROPERTIES_PREFIX = "TBLPROPERTIES"
462        PARSE_JSON_NAME = None
463        PAD_FILL_PATTERN_IS_REQUIRED = True
464        SUPPORTS_MEDIAN = False
465        ARRAY_SIZE_NAME = "SIZE"
466
467        EXPRESSIONS_WITHOUT_NESTED_CTES = {
468            exp.Insert,
469            exp.Select,
470            exp.Subquery,
471            exp.SetOperation,
472        }
473
474        SUPPORTED_JSON_PATH_PARTS = {
475            exp.JSONPathKey,
476            exp.JSONPathRoot,
477            exp.JSONPathSubscript,
478            exp.JSONPathWildcard,
479        }
480
481        TYPE_MAPPING = {
482            **generator.Generator.TYPE_MAPPING,
483            exp.DataType.Type.BIT: "BOOLEAN",
484            exp.DataType.Type.DATETIME: "TIMESTAMP",
485            exp.DataType.Type.ROWVERSION: "BINARY",
486            exp.DataType.Type.TEXT: "STRING",
487            exp.DataType.Type.TIME: "TIMESTAMP",
488            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
489            exp.DataType.Type.UTINYINT: "SMALLINT",
490            exp.DataType.Type.VARBINARY: "BINARY",
491        }
492
493        TRANSFORMS = {
494            **generator.Generator.TRANSFORMS,
495            exp.Group: transforms.preprocess([transforms.unalias_group]),
496            exp.Property: property_sql,
497            exp.AnyValue: rename_func("FIRST"),
498            exp.ApproxDistinct: approx_count_distinct_sql,
499            exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
500            exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
501            exp.ArrayConcat: rename_func("CONCAT"),
502            exp.ArrayToString: lambda self, e: self.func("CONCAT_WS", e.expression, e.this),
503            exp.ArraySort: _array_sort_sql,
504            exp.With: no_recursive_cte_sql,
505            exp.DateAdd: _add_date_sql,
506            exp.DateDiff: _date_diff_sql,
507            exp.DateStrToDate: datestrtodate_sql,
508            exp.DateSub: _add_date_sql,
509            exp.DateToDi: lambda self,
510            e: f"CAST(DATE_FORMAT({self.sql(e, 'this')}, {Hive.DATEINT_FORMAT}) AS INT)",
511            exp.DiToDate: lambda self,
512            e: f"TO_DATE(CAST({self.sql(e, 'this')} AS STRING), {Hive.DATEINT_FORMAT})",
513            exp.FileFormatProperty: lambda self,
514            e: f"STORED AS {self.sql(e, 'this') if isinstance(e.this, exp.InputOutputFormat) else e.name.upper()}",
515            exp.FromBase64: rename_func("UNBASE64"),
516            exp.GenerateSeries: sequence_sql,
517            exp.GenerateDateArray: sequence_sql,
518            exp.If: if_sql(),
519            exp.ILike: no_ilike_sql,
520            exp.IsNan: rename_func("ISNAN"),
521            exp.JSONExtract: lambda self, e: self.func("GET_JSON_OBJECT", e.this, e.expression),
522            exp.JSONExtractScalar: lambda self, e: self.func(
523                "GET_JSON_OBJECT", e.this, e.expression
524            ),
525            exp.JSONFormat: _json_format_sql,
526            exp.Left: left_to_substring_sql,
527            exp.Map: var_map_sql,
528            exp.Max: max_or_greatest,
529            exp.MD5Digest: lambda self, e: self.func("UNHEX", self.func("MD5", e.this)),
530            exp.Min: min_or_least,
531            exp.MonthsBetween: lambda self, e: self.func("MONTHS_BETWEEN", e.this, e.expression),
532            exp.NotNullColumnConstraint: lambda _, e: (
533                "" if e.args.get("allow_null") else "NOT NULL"
534            ),
535            exp.VarMap: var_map_sql,
536            exp.Create: preprocess(
537                [
538                    remove_unique_constraints,
539                    ctas_with_tmp_tables_to_create_tmp_view,
540                    move_schema_columns_to_partitioned_by,
541                ]
542            ),
543            exp.Quantile: rename_func("PERCENTILE"),
544            exp.ApproxQuantile: rename_func("PERCENTILE_APPROX"),
545            exp.RegexpExtract: regexp_extract_sql,
546            exp.RegexpExtractAll: regexp_extract_sql,
547            exp.RegexpReplace: regexp_replace_sql,
548            exp.RegexpLike: lambda self, e: self.binary(e, "RLIKE"),
549            exp.RegexpSplit: rename_func("SPLIT"),
550            exp.Right: right_to_substring_sql,
551            exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
552            exp.ArrayUniqueAgg: rename_func("COLLECT_SET"),
553            exp.Split: lambda self, e: self.func(
554                "SPLIT", e.this, self.func("CONCAT", "'\\\\Q'", e.expression, "'\\\\E'")
555            ),
556            exp.Select: transforms.preprocess(
557                [
558                    transforms.eliminate_qualify,
559                    transforms.eliminate_distinct_on,
560                    partial(transforms.unnest_to_explode, unnest_using_arrays_zip=False),
561                    transforms.any_to_exists,
562                ]
563            ),
564            exp.StrPosition: lambda self, e: strposition_sql(
565                self, e, func_name="LOCATE", supports_position=True
566            ),
567            exp.StrToDate: _str_to_date_sql,
568            exp.StrToTime: _str_to_time_sql,
569            exp.StrToUnix: _str_to_unix_sql,
570            exp.StructExtract: struct_extract_sql,
571            exp.Table: transforms.preprocess([transforms.unnest_generate_series]),
572            exp.TimeStrToDate: rename_func("TO_DATE"),
573            exp.TimeStrToTime: timestrtotime_sql,
574            exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
575            exp.TimestampTrunc: lambda self, e: self.func("TRUNC", e.this, unit_to_str(e)),
576            exp.TimeToStr: lambda self, e: self.func("DATE_FORMAT", e.this, self.format_time(e)),
577            exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"),
578            exp.ToBase64: rename_func("BASE64"),
579            exp.TsOrDiToDi: lambda self,
580            e: f"CAST(SUBSTR(REPLACE(CAST({self.sql(e, 'this')} AS STRING), '-', ''), 1, 8) AS INT)",
581            exp.TsOrDsAdd: _add_date_sql,
582            exp.TsOrDsDiff: _date_diff_sql,
583            exp.TsOrDsToDate: _to_date_sql,
584            exp.TryCast: no_trycast_sql,
585            exp.Unicode: rename_func("ASCII"),
586            exp.UnixToStr: lambda self, e: self.func(
587                "FROM_UNIXTIME", e.this, time_format("hive")(self, e)
588            ),
589            exp.UnixToTime: _unix_to_time_sql,
590            exp.UnixToTimeStr: rename_func("FROM_UNIXTIME"),
591            exp.Unnest: rename_func("EXPLODE"),
592            exp.PartitionedByProperty: lambda self, e: f"PARTITIONED BY {self.sql(e, 'this')}",
593            exp.NumberToStr: rename_func("FORMAT_NUMBER"),
594            exp.National: lambda self, e: self.national_sql(e, prefix=""),
595            exp.ClusteredColumnConstraint: lambda self,
596            e: f"({self.expressions(e, 'this', indent=False)})",
597            exp.NonClusteredColumnConstraint: lambda self,
598            e: f"({self.expressions(e, 'this', indent=False)})",
599            exp.NotForReplicationColumnConstraint: lambda *_: "",
600            exp.OnProperty: lambda *_: "",
601            exp.PrimaryKeyColumnConstraint: lambda *_: "PRIMARY KEY",
602            exp.WeekOfYear: rename_func("WEEKOFYEAR"),
603            exp.DayOfMonth: rename_func("DAYOFMONTH"),
604            exp.DayOfWeek: rename_func("DAYOFWEEK"),
605            exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
606                rename_func("LEVENSHTEIN")
607            ),
608        }
609
610        PROPERTIES_LOCATION = {
611            **generator.Generator.PROPERTIES_LOCATION,
612            exp.FileFormatProperty: exp.Properties.Location.POST_SCHEMA,
613            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
614            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
615            exp.WithDataProperty: exp.Properties.Location.UNSUPPORTED,
616        }
617
618        def unnest_sql(self, expression: exp.Unnest) -> str:
619            return rename_func("EXPLODE")(self, expression)
620
621        def _jsonpathkey_sql(self, expression: exp.JSONPathKey) -> str:
622            if isinstance(expression.this, exp.JSONPathWildcard):
623                self.unsupported("Unsupported wildcard in JSONPathKey expression")
624                return ""
625
626            return super()._jsonpathkey_sql(expression)
627
628        def parameter_sql(self, expression: exp.Parameter) -> str:
629            this = self.sql(expression, "this")
630            expression_sql = self.sql(expression, "expression")
631
632            parent = expression.parent
633            this = f"{this}:{expression_sql}" if expression_sql else this
634
635            if isinstance(parent, exp.EQ) and isinstance(parent.parent, exp.SetItem):
636                # We need to produce SET key = value instead of SET ${key} = value
637                return this
638
639            return f"${{{this}}}"
640
641        def schema_sql(self, expression: exp.Schema) -> str:
642            for ordered in expression.find_all(exp.Ordered):
643                if ordered.args.get("desc") is False:
644                    ordered.set("desc", None)
645
646            return super().schema_sql(expression)
647
648        def constraint_sql(self, expression: exp.Constraint) -> str:
649            for prop in list(expression.find_all(exp.Properties)):
650                prop.pop()
651
652            this = self.sql(expression, "this")
653            expressions = self.expressions(expression, sep=" ", flat=True)
654            return f"CONSTRAINT {this} {expressions}"
655
656        def rowformatserdeproperty_sql(self, expression: exp.RowFormatSerdeProperty) -> str:
657            serde_props = self.sql(expression, "serde_properties")
658            serde_props = f" {serde_props}" if serde_props else ""
659            return f"ROW FORMAT SERDE {self.sql(expression, 'this')}{serde_props}"
660
661        def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
662            return self.func(
663                "COLLECT_LIST",
664                expression.this.this if isinstance(expression.this, exp.Order) else expression.this,
665            )
666
667        def datatype_sql(self, expression: exp.DataType) -> str:
668            if expression.this in self.PARAMETERIZABLE_TEXT_TYPES and (
669                not expression.expressions or expression.expressions[0].name == "MAX"
670            ):
671                expression = exp.DataType.build("text")
672            elif expression.is_type(exp.DataType.Type.TEXT) and expression.expressions:
673                expression.set("this", exp.DataType.Type.VARCHAR)
674            elif expression.this in exp.DataType.TEMPORAL_TYPES:
675                expression = exp.DataType.build(expression.this)
676            elif expression.is_type("float"):
677                size_expression = expression.find(exp.DataTypeParam)
678                if size_expression:
679                    size = int(size_expression.name)
680                    expression = (
681                        exp.DataType.build("float") if size <= 32 else exp.DataType.build("double")
682                    )
683
684            return super().datatype_sql(expression)
685
686        def version_sql(self, expression: exp.Version) -> str:
687            sql = super().version_sql(expression)
688            return sql.replace("FOR ", "", 1)
689
690        def struct_sql(self, expression: exp.Struct) -> str:
691            values = []
692
693            for i, e in enumerate(expression.expressions):
694                if isinstance(e, exp.PropertyEQ):
695                    self.unsupported("Hive does not support named structs.")
696                    values.append(e.expression)
697                else:
698                    values.append(e)
699
700            return self.func("STRUCT", *values)
701
702        def alterset_sql(self, expression: exp.AlterSet) -> str:
703            exprs = self.expressions(expression, flat=True)
704            exprs = f" {exprs}" if exprs else ""
705            location = self.sql(expression, "location")
706            location = f" LOCATION {location}" if location else ""
707            file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
708            file_format = f" FILEFORMAT {file_format}" if file_format else ""
709            serde = self.sql(expression, "serde")
710            serde = f" SERDE {serde}" if serde else ""
711            tags = self.expressions(expression, key="tag", flat=True, sep="")
712            tags = f" TAGS {tags}" if tags else ""
713
714            return f"SET{serde}{exprs}{location}{file_format}{tags}"
715
716        def serdeproperties_sql(self, expression: exp.SerdeProperties) -> str:
717            prefix = "WITH " if expression.args.get("with") else ""
718            exprs = self.expressions(expression, flat=True)
719
720            return f"{prefix}SERDEPROPERTIES ({exprs})"
721
722        def exists_sql(self, expression: exp.Exists):
723            if expression.expression:
724                return self.function_fallback_sql(expression)
725
726            return super().exists_sql(expression)

Generator converts a given syntax tree to the corresponding SQL string.

Arguments:
  • pretty: Whether to format the produced SQL string. Default: False.
  • identify: Determines when an identifier should be quoted. Possible values are: False (default): Never quote, except in cases where it's mandatory by the dialect. True or 'always': Always quote. 'safe': Only quote identifiers that are case insensitive.
  • normalize: Whether to normalize identifiers to lowercase. Default: False.
  • pad: The pad size in a formatted string. For example, this affects the indentation of a projection in a query, relative to its nesting level. Default: 2.
  • indent: The indentation size in a formatted string. For example, this affects the indentation of subqueries and filters under a WHERE clause. Default: 2.
  • normalize_functions: How to normalize function names. Possible values are: "upper" or True (default): Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.
  • unsupported_level: Determines the generator's behavior when it encounters unsupported expressions. Default ErrorLevel.WARN.
  • max_unsupported: Maximum number of unsupported messages to include in a raised UnsupportedError. This is only relevant if unsupported_level is ErrorLevel.RAISE. Default: 3
  • leading_comma: Whether the comma is leading or trailing in select expressions. This is only relevant when generating in pretty mode. Default: False
  • max_text_width: The max number of characters in a segment before creating new lines in pretty mode. The default is on the smaller end because the length only represents a segment and not the true line length. Default: 80
  • comments: Whether to preserve comments in the output SQL code. Default: True
LIMIT_FETCH = 'LIMIT'
TABLESAMPLE_WITH_METHOD = False
JOIN_HINTS = False
TABLE_HINTS = False
QUERY_HINTS = False
INDEX_ON = 'ON TABLE'
EXTRACT_ALLOWS_QUOTES = False
NVL2_SUPPORTED = False
LAST_DAY_SUPPORTS_DATE_PART = False
JSON_PATH_SINGLE_QUOTE_ESCAPE = True
SUPPORTS_TO_NUMBER = False
WITH_PROPERTIES_PREFIX = 'TBLPROPERTIES'
PARSE_JSON_NAME = None
PAD_FILL_PATTERN_IS_REQUIRED = True
SUPPORTS_MEDIAN = False
ARRAY_SIZE_NAME = 'SIZE'
EXPRESSIONS_WITHOUT_NESTED_CTES = {<class 'sqlglot.expressions.Insert'>, <class 'sqlglot.expressions.SetOperation'>, <class 'sqlglot.expressions.Subquery'>, <class 'sqlglot.expressions.Select'>}
TYPE_MAPPING = {<Type.DATETIME2: 'DATETIME2'>: 'TIMESTAMP', <Type.NCHAR: 'NCHAR'>: 'CHAR', <Type.NVARCHAR: 'NVARCHAR'>: 'VARCHAR', <Type.MEDIUMTEXT: 'MEDIUMTEXT'>: 'TEXT', <Type.LONGTEXT: 'LONGTEXT'>: 'TEXT', <Type.TINYTEXT: 'TINYTEXT'>: 'TEXT', <Type.MEDIUMBLOB: 'MEDIUMBLOB'>: 'BLOB', <Type.LONGBLOB: 'LONGBLOB'>: 'BLOB', <Type.TINYBLOB: 'TINYBLOB'>: 'BLOB', <Type.INET: 'INET'>: 'INET', <Type.ROWVERSION: 'ROWVERSION'>: 'BINARY', <Type.SMALLDATETIME: 'SMALLDATETIME'>: 'TIMESTAMP', <Type.BIT: 'BIT'>: 'BOOLEAN', <Type.DATETIME: 'DATETIME'>: 'TIMESTAMP', <Type.TEXT: 'TEXT'>: 'STRING', <Type.TIME: 'TIME'>: 'TIMESTAMP', <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>: 'TIMESTAMP', <Type.UTINYINT: 'UTINYINT'>: 'SMALLINT', <Type.VARBINARY: 'VARBINARY'>: 'BINARY'}
TRANSFORMS = {<class 'sqlglot.expressions.JSONPathKey'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathRoot'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathSubscript'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathWildcard'>: <function <lambda>>, <class 'sqlglot.expressions.AllowedValuesProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AnalyzeColumns'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AnalyzeWith'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ArrayContainsAll'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ArrayOverlaps'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.BackupProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CaseSpecificColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Ceil'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ClusteredColumnConstraint'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.CollateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CommentColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ConnectByRoot'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DateFormatColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DefaultColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DynamicProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EmptyProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EncodeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EphemeralColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExcludeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Except'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExternalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Floor'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.GlobalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.HeapProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IcebergProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InheritsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InlineLengthColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Intersect'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IntervalSpan'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Int64'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LanguageProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LocationProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LogProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.MaterializedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NonClusteredColumnConstraint'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NotForReplicationColumnConstraint'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.OnCommitProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnProperty'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.OnUpdateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Operator'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OutputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PathColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PivotAny'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ProjectionPolicyColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ReturnsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SampleProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SecureProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SecurityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetConfigProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SettingsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SharingProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StabilityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Stream'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StreamingTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StrictProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SwapTable'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TemporaryProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Tags'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TitleColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToMap'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransformModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransientProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Union'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UnloggedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UsingData'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Uuid'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UppercaseColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VarMap'>: <function var_map_sql>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VolatileProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithProcedureOptions'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithSchemaBindingProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithOperator'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Group'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.Property'>: <function property_sql>, <class 'sqlglot.expressions.AnyValue'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ApproxDistinct'>: <function approx_count_distinct_sql>, <class 'sqlglot.expressions.ArgMax'>: <function arg_max_or_min_no_count.<locals>._arg_max_or_min_sql>, <class 'sqlglot.expressions.ArgMin'>: <function arg_max_or_min_no_count.<locals>._arg_max_or_min_sql>, <class 'sqlglot.expressions.ArrayConcat'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArrayToString'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.ArraySort'>: <function _array_sort_sql>, <class 'sqlglot.expressions.With'>: <function no_recursive_cte_sql>, <class 'sqlglot.expressions.DateAdd'>: <function _add_date_sql>, <class 'sqlglot.expressions.DateDiff'>: <function _date_diff_sql>, <class 'sqlglot.expressions.DateStrToDate'>: <function datestrtodate_sql>, <class 'sqlglot.expressions.DateSub'>: <function _add_date_sql>, <class 'sqlglot.expressions.DateToDi'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.DiToDate'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.FileFormatProperty'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.FromBase64'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.GenerateSeries'>: <function sequence_sql>, <class 'sqlglot.expressions.GenerateDateArray'>: <function sequence_sql>, <class 'sqlglot.expressions.If'>: <function if_sql.<locals>._if_sql>, <class 'sqlglot.expressions.ILike'>: <function no_ilike_sql>, <class 'sqlglot.expressions.IsNan'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.JSONExtract'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.JSONExtractScalar'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.JSONFormat'>: <function _json_format_sql>, <class 'sqlglot.expressions.Left'>: <function left_to_substring_sql>, <class 'sqlglot.expressions.Map'>: <function var_map_sql>, <class 'sqlglot.expressions.Max'>: <function max_or_greatest>, <class 'sqlglot.expressions.MD5Digest'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.Min'>: <function min_or_least>, <class 'sqlglot.expressions.MonthsBetween'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.NotNullColumnConstraint'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.Create'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.Quantile'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ApproxQuantile'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.RegexpExtract'>: <function regexp_extract_sql>, <class 'sqlglot.expressions.RegexpExtractAll'>: <function regexp_extract_sql>, <class 'sqlglot.expressions.RegexpReplace'>: <function regexp_replace_sql>, <class 'sqlglot.expressions.RegexpLike'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.RegexpSplit'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Right'>: <function right_to_substring_sql>, <class 'sqlglot.expressions.SchemaCommentProperty'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.ArrayUniqueAgg'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Split'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.Select'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.StrPosition'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.StrToDate'>: <function _str_to_date_sql>, <class 'sqlglot.expressions.StrToTime'>: <function _str_to_time_sql>, <class 'sqlglot.expressions.StrToUnix'>: <function _str_to_unix_sql>, <class 'sqlglot.expressions.StructExtract'>: <function struct_extract_sql>, <class 'sqlglot.expressions.Table'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.TimeStrToDate'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TimeStrToTime'>: <function timestrtotime_sql>, <class 'sqlglot.expressions.TimeStrToUnix'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TimestampTrunc'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.TimeToStr'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.TimeToUnix'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ToBase64'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TsOrDiToDi'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.TsOrDsAdd'>: <function _add_date_sql>, <class 'sqlglot.expressions.TsOrDsDiff'>: <function _date_diff_sql>, <class 'sqlglot.expressions.TsOrDsToDate'>: <function _to_date_sql>, <class 'sqlglot.expressions.TryCast'>: <function no_trycast_sql>, <class 'sqlglot.expressions.Unicode'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.UnixToStr'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.UnixToTime'>: <function _unix_to_time_sql>, <class 'sqlglot.expressions.UnixToTimeStr'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Unnest'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.PartitionedByProperty'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.NumberToStr'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.National'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.PrimaryKeyColumnConstraint'>: <function Hive.Generator.<lambda>>, <class 'sqlglot.expressions.WeekOfYear'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.DayOfMonth'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.DayOfWeek'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Levenshtein'>: <function rename_func.<locals>.<lambda>>}
PROPERTIES_LOCATION = {<class 'sqlglot.expressions.AllowedValuesProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AlgorithmProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.AutoIncrementProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BackupProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BlockCompressionProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CharacterSetProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ChecksumProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CollateProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Cluster'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ClusteredByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistributedByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DuplicateKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DataBlocksizeProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.DataDeletionProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DefinerProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.DictRange'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DictProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DynamicProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.DistKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistStyleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.EmptyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.EncodeProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.EngineProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExternalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.FallbackProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.FileFormatProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.FreespaceProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.GlobalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.HeapProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.InheritsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IcebergProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.IncludeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.InputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IsolatedLoadingProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.JournalProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.LanguageProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LikeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LocationProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockingProperty'>: <Location.POST_ALIAS: 'POST_ALIAS'>, <class 'sqlglot.expressions.LogProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.MaterializedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.MergeBlockRatioProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.OnProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OnCommitProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.Order'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OutputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PartitionedByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PartitionedOfProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PrimaryKey'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Property'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ReturnsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatDelimitedProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatSerdeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SampleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SchemaCommentProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SecureProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.SecurityProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SerdeProperties'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Set'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SettingsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SetProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.SetConfigProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SharingProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SequenceProperties'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SortKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.StabilityProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.StreamingTableProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.StrictProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Tags'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.TemporaryProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.ToTableProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.TransientProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.TransformModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.MergeTreeTTL'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.UnloggedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.VolatileProperty'>: <Location.UNSUPPORTED: 'UNSUPPORTED'>, <class 'sqlglot.expressions.WithDataProperty'>: <Location.UNSUPPORTED: 'UNSUPPORTED'>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.WithProcedureOptions'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.WithSchemaBindingProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.WithSystemVersioningProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>}
def unnest_sql(self, expression: sqlglot.expressions.Unnest) -> str:
618        def unnest_sql(self, expression: exp.Unnest) -> str:
619            return rename_func("EXPLODE")(self, expression)
def parameter_sql(self, expression: sqlglot.expressions.Parameter) -> str:
628        def parameter_sql(self, expression: exp.Parameter) -> str:
629            this = self.sql(expression, "this")
630            expression_sql = self.sql(expression, "expression")
631
632            parent = expression.parent
633            this = f"{this}:{expression_sql}" if expression_sql else this
634
635            if isinstance(parent, exp.EQ) and isinstance(parent.parent, exp.SetItem):
636                # We need to produce SET key = value instead of SET ${key} = value
637                return this
638
639            return f"${{{this}}}"
def schema_sql(self, expression: sqlglot.expressions.Schema) -> str:
641        def schema_sql(self, expression: exp.Schema) -> str:
642            for ordered in expression.find_all(exp.Ordered):
643                if ordered.args.get("desc") is False:
644                    ordered.set("desc", None)
645
646            return super().schema_sql(expression)
def constraint_sql(self, expression: sqlglot.expressions.Constraint) -> str:
648        def constraint_sql(self, expression: exp.Constraint) -> str:
649            for prop in list(expression.find_all(exp.Properties)):
650                prop.pop()
651
652            this = self.sql(expression, "this")
653            expressions = self.expressions(expression, sep=" ", flat=True)
654            return f"CONSTRAINT {this} {expressions}"
def rowformatserdeproperty_sql(self, expression: sqlglot.expressions.RowFormatSerdeProperty) -> str:
656        def rowformatserdeproperty_sql(self, expression: exp.RowFormatSerdeProperty) -> str:
657            serde_props = self.sql(expression, "serde_properties")
658            serde_props = f" {serde_props}" if serde_props else ""
659            return f"ROW FORMAT SERDE {self.sql(expression, 'this')}{serde_props}"
def arrayagg_sql(self, expression: sqlglot.expressions.ArrayAgg) -> str:
661        def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
662            return self.func(
663                "COLLECT_LIST",
664                expression.this.this if isinstance(expression.this, exp.Order) else expression.this,
665            )
def datatype_sql(self, expression: sqlglot.expressions.DataType) -> str:
667        def datatype_sql(self, expression: exp.DataType) -> str:
668            if expression.this in self.PARAMETERIZABLE_TEXT_TYPES and (
669                not expression.expressions or expression.expressions[0].name == "MAX"
670            ):
671                expression = exp.DataType.build("text")
672            elif expression.is_type(exp.DataType.Type.TEXT) and expression.expressions:
673                expression.set("this", exp.DataType.Type.VARCHAR)
674            elif expression.this in exp.DataType.TEMPORAL_TYPES:
675                expression = exp.DataType.build(expression.this)
676            elif expression.is_type("float"):
677                size_expression = expression.find(exp.DataTypeParam)
678                if size_expression:
679                    size = int(size_expression.name)
680                    expression = (
681                        exp.DataType.build("float") if size <= 32 else exp.DataType.build("double")
682                    )
683
684            return super().datatype_sql(expression)
def version_sql(self, expression: sqlglot.expressions.Version) -> str:
686        def version_sql(self, expression: exp.Version) -> str:
687            sql = super().version_sql(expression)
688            return sql.replace("FOR ", "", 1)
def struct_sql(self, expression: sqlglot.expressions.Struct) -> str:
690        def struct_sql(self, expression: exp.Struct) -> str:
691            values = []
692
693            for i, e in enumerate(expression.expressions):
694                if isinstance(e, exp.PropertyEQ):
695                    self.unsupported("Hive does not support named structs.")
696                    values.append(e.expression)
697                else:
698                    values.append(e)
699
700            return self.func("STRUCT", *values)
def alterset_sql(self, expression: sqlglot.expressions.AlterSet) -> str:
702        def alterset_sql(self, expression: exp.AlterSet) -> str:
703            exprs = self.expressions(expression, flat=True)
704            exprs = f" {exprs}" if exprs else ""
705            location = self.sql(expression, "location")
706            location = f" LOCATION {location}" if location else ""
707            file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
708            file_format = f" FILEFORMAT {file_format}" if file_format else ""
709            serde = self.sql(expression, "serde")
710            serde = f" SERDE {serde}" if serde else ""
711            tags = self.expressions(expression, key="tag", flat=True, sep="")
712            tags = f" TAGS {tags}" if tags else ""
713
714            return f"SET{serde}{exprs}{location}{file_format}{tags}"
def serdeproperties_sql(self, expression: sqlglot.expressions.SerdeProperties) -> str:
716        def serdeproperties_sql(self, expression: exp.SerdeProperties) -> str:
717            prefix = "WITH " if expression.args.get("with") else ""
718            exprs = self.expressions(expression, flat=True)
719
720            return f"{prefix}SERDEPROPERTIES ({exprs})"
def exists_sql(self, expression: sqlglot.expressions.Exists):
722        def exists_sql(self, expression: exp.Exists):
723            if expression.expression:
724                return self.function_fallback_sql(expression)
725
726            return super().exists_sql(expression)
SELECT_KINDS: Tuple[str, ...] = ()
TRY_SUPPORTED = False
SUPPORTS_UESCAPE = False
Inherited Members
sqlglot.generator.Generator
Generator
NULL_ORDERING_SUPPORTED
IGNORE_NULLS_IN_FUNC
LOCKING_READS_SUPPORTED
EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE
WRAP_DERIVED_VALUES
CREATE_FUNCTION_RETURN_AS
MATCHED_BY_SOURCE
SINGLE_STRING_INTERVAL
INTERVAL_ALLOWS_PLURAL_FORM
LIMIT_ONLY_LITERALS
RENAME_TABLE_WITH_DB
GROUPINGS_SEP
QUERY_HINT_SEP
IS_BOOL_ALLOWED
DUPLICATE_KEY_UPDATE_WITH_SET
LIMIT_IS_TOP
RETURNING_END
TZ_TO_WITH_TIME_ZONE
VALUES_AS_TABLE
ALTER_TABLE_INCLUDE_COLUMN_KEYWORD
UNNEST_WITH_ORDINALITY
AGGREGATE_FILTER_SUPPORTED
SEMI_ANTI_JOIN_WITH_SIDE
COMPUTED_COLUMN_WITH_TYPE
SUPPORTS_TABLE_COPY
TABLESAMPLE_REQUIRES_PARENS
TABLESAMPLE_SIZE_IS_ROWS
TABLESAMPLE_KEYWORDS
TABLESAMPLE_SEED_KEYWORD
COLLATE_IS_FUNC
DATA_TYPE_SPECIFIERS_ALLOWED
ENSURE_BOOLS
CTE_RECURSIVE_KEYWORD_REQUIRED
SUPPORTS_SINGLE_ARG_CONCAT
SUPPORTS_TABLE_ALIAS_COLUMNS
UNPIVOT_ALIASES_ARE_IDENTIFIERS
JSON_KEY_VALUE_PAIR_SEP
INSERT_OVERWRITE
SUPPORTS_SELECT_INTO
SUPPORTS_UNLOGGED_TABLES
SUPPORTS_CREATE_TABLE_LIKE
LIKE_PROPERTY_INSIDE_SCHEMA
MULTI_ARG_DISTINCT
JSON_TYPE_REQUIRED_FOR_EXTRACTION
JSON_PATH_BRACKETED_KEY_SUPPORTED
CAN_IMPLEMENT_ARRAY_ANY
SET_OP_MODIFIERS
COPY_PARAMS_ARE_WRAPPED
COPY_PARAMS_EQ_REQUIRED
COPY_HAS_INTO_KEYWORD
STAR_EXCEPT
HEX_FUNC
QUOTE_JSON_PATH
SUPPORTS_EXPLODING_PROJECTIONS
ARRAY_CONCAT_IS_VAR_LEN
SUPPORTS_CONVERT_TIMEZONE
SUPPORTS_UNIX_SECONDS
ARRAY_SIZE_DIM_REQUIRED
TIME_PART_SINGULARS
AFTER_HAVING_MODIFIER_TRANSFORMS
TOKEN_MAPPING
STRUCT_DELIMITER
PARAMETER_TOKEN
NAMED_PLACEHOLDER_TOKEN
EXPRESSION_PRECEDES_PROPERTIES_CREATABLES
RESERVED_KEYWORDS
WITH_SEPARATED_COMMENTS
EXCLUDE_COMMENTS
UNWRAPPED_INTERVAL_VALUES
PARAMETERIZABLE_TEXT_TYPES
SENTINEL_LINE_BREAK
pretty
identify
normalize
pad
unsupported_level
max_unsupported
leading_comma
max_text_width
comments
dialect
normalize_functions
unsupported_messages
generate
preprocess
unsupported
sep
seg
pad_comment
maybe_comment
wrap
no_identify
normalize_func
indent
sql
uncache_sql
cache_sql
characterset_sql
column_parts
column_sql
columnposition_sql
columndef_sql
columnconstraint_sql
computedcolumnconstraint_sql
autoincrementcolumnconstraint_sql
compresscolumnconstraint_sql
generatedasidentitycolumnconstraint_sql
generatedasrowcolumnconstraint_sql
periodforsystemtimeconstraint_sql
notnullcolumnconstraint_sql
transformcolumnconstraint_sql
primarykeycolumnconstraint_sql
uniquecolumnconstraint_sql
createable_sql
create_sql
sequenceproperties_sql
clone_sql
describe_sql
heredoc_sql
prepend_ctes
with_sql
cte_sql
tablealias_sql
bitstring_sql
hexstring_sql
bytestring_sql
unicodestring_sql
rawstring_sql
datatypeparam_sql
directory_sql
delete_sql
drop_sql
set_operation
set_operations
fetch_sql
filter_sql
hint_sql
indexparameters_sql
index_sql
identifier_sql
hex_sql
lowerhex_sql
inputoutputformat_sql
national_sql
partition_sql
properties_sql
root_properties
properties
with_properties
locate_properties
property_name
property_sql
likeproperty_sql
fallbackproperty_sql
journalproperty_sql
freespaceproperty_sql
checksumproperty_sql
mergeblockratioproperty_sql
datablocksizeproperty_sql
blockcompressionproperty_sql
isolatedloadingproperty_sql
partitionboundspec_sql
partitionedofproperty_sql
lockingproperty_sql
withdataproperty_sql
withsystemversioningproperty_sql
insert_sql
introducer_sql
kill_sql
pseudotype_sql
objectidentifier_sql
onconflict_sql
returning_sql
rowformatdelimitedproperty_sql
withtablehint_sql
indextablehint_sql
historicaldata_sql
table_parts
table_sql
tablesample_sql
pivot_sql
tuple_sql
update_sql
values_sql
var_sql
into_sql
from_sql
groupingsets_sql
rollup_sql
cube_sql
group_sql
having_sql
connect_sql
prior_sql
join_sql
lambda_sql
lateral_op
lateral_sql
limit_sql
offset_sql
setitem_sql
set_sql
pragma_sql
lock_sql
literal_sql
escape_str
loaddata_sql
null_sql
boolean_sql
order_sql
withfill_sql
cluster_sql
distribute_sql
sort_sql
ordered_sql
matchrecognizemeasure_sql
matchrecognize_sql
query_modifiers
options_modifier
queryoption_sql
offset_limit_modifiers
after_limit_modifiers
select_sql
schema_columns_sql
star_sql
sessionparameter_sql
placeholder_sql
subquery_sql
qualify_sql
prewhere_sql
where_sql
window_sql
partition_by_sql
windowspec_sql
withingroup_sql
between_sql
bracket_offset_expressions
bracket_sql
all_sql
any_sql
case_sql
nextvaluefor_sql
extract_sql
trim_sql
convert_concat_args
concat_sql
concatws_sql
check_sql
foreignkey_sql
primarykey_sql
if_sql
matchagainst_sql
jsonkeyvalue_sql
jsonpath_sql
json_path_part
formatjson_sql
jsonobject_sql
jsonobjectagg_sql
jsonarray_sql
jsonarrayagg_sql
jsoncolumndef_sql
jsonschema_sql
jsontable_sql
openjsoncolumndef_sql
openjson_sql
in_sql
in_unnest_op
interval_sql
return_sql
reference_sql
anonymous_sql
paren_sql
neg_sql
not_sql
alias_sql
pivotalias_sql
aliases_sql
atindex_sql
attimezone_sql
fromtimezone_sql
add_sql
and_sql
or_sql
xor_sql
connector_sql
bitwiseand_sql
bitwiseleftshift_sql
bitwisenot_sql
bitwiseor_sql
bitwiserightshift_sql
bitwisexor_sql
cast_sql
currentdate_sql
collate_sql
command_sql
comment_sql
mergetreettlaction_sql
mergetreettl_sql
transaction_sql
commit_sql
rollback_sql
altercolumn_sql
alterdiststyle_sql
altersortkey_sql
alterrename_sql
renamecolumn_sql
alter_sql
add_column_sql
droppartition_sql
addconstraint_sql
distinct_sql
ignorenulls_sql
respectnulls_sql
havingmax_sql
intdiv_sql
dpipe_sql
div_sql
safedivide_sql
overlaps_sql
distance_sql
dot_sql
eq_sql
propertyeq_sql
escape_sql
glob_sql
gt_sql
gte_sql
ilike_sql
ilikeany_sql
is_sql
like_sql
likeany_sql
similarto_sql
lt_sql
lte_sql
mod_sql
mul_sql
neq_sql
nullsafeeq_sql
nullsafeneq_sql
slice_sql
sub_sql
trycast_sql
try_sql
log_sql
use_sql
binary
ceil_floor
function_fallback_sql
func
format_args
too_wide
format_time
expressions
op_expressions
naked_property
tag_sql
token_sql
userdefinedfunction_sql
joinhint_sql
kwarg_sql
when_sql
whens_sql
merge_sql
tochar_sql
tonumber_sql
dictproperty_sql
dictrange_sql
dictsubproperty_sql
duplicatekeyproperty_sql
uniquekeyproperty_sql
distributedbyproperty_sql
oncluster_sql
clusteredbyproperty_sql
anyvalue_sql
querytransform_sql
indexconstraintoption_sql
checkcolumnconstraint_sql
indexcolumnconstraint_sql
nvl2_sql
comprehension_sql
columnprefix_sql
opclass_sql
predict_sql
forin_sql
refresh_sql
toarray_sql
tsordstotime_sql
tsordstotimestamp_sql
tsordstodatetime_sql
tsordstodate_sql
unixdate_sql
lastday_sql
dateadd_sql
arrayany_sql
partitionrange_sql
truncatetable_sql
convert_sql
copyparameter_sql
credentials_sql
copy_sql
semicolon_sql
datadeletionproperty_sql
maskingpolicycolumnconstraint_sql
gapfill_sql
scope_resolution
scoperesolution_sql
parsejson_sql
rand_sql
changes_sql
pad_sql
summarize_sql
explodinggenerateseries_sql
arrayconcat_sql
converttimezone_sql
json_sql
jsonvalue_sql
conditionalinsert_sql
multitableinserts_sql
oncondition_sql
jsonextractquote_sql
jsonexists_sql
apply_sql
grant_sql
grantprivilege_sql
grantprincipal_sql
columns_sql
overlay_sql
todouble_sql
string_sql
median_sql
overflowtruncatebehavior_sql
unixseconds_sql
arraysize_sql
attach_sql
detach_sql
attachoption_sql
featuresattime_sql
watermarkcolumnconstraint_sql
encodeproperty_sql
includeproperty_sql
xmlelement_sql
partitionbyrangeproperty_sql
partitionbyrangepropertydynamic_sql
unpivotcolumns_sql
analyzesample_sql
analyzestatistics_sql
analyzehistogram_sql
analyzedelete_sql
analyzelistchainedrows_sql
analyzevalidate_sql
analyze_sql
xmltable_sql
xmlnamespace_sql