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

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
EXPRESSIONS_WITHOUT_NESTED_CTES = {<class 'sqlglot.expressions.SetOperation'>, <class 'sqlglot.expressions.Subquery'>, <class 'sqlglot.expressions.Select'>, <class 'sqlglot.expressions.Insert'>}
TYPE_MAPPING = {<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.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.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.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.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.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.TemporaryProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TagColumnConstraint'>: <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.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.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.ArraySize'>: <function rename_func.<locals>.<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.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.SafeDivide'>: <function no_safe_divide_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 strposition_to_locate_sql>, <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.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>>}
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.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.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.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.WithSchemaBindingProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.WithSystemVersioningProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>}
def unnest_sql(self, expression: sqlglot.expressions.Unnest) -> str:
607        def unnest_sql(self, expression: exp.Unnest) -> str:
608            return rename_func("EXPLODE")(self, expression)
def parameter_sql(self, expression: sqlglot.expressions.Parameter) -> str:
617        def parameter_sql(self, expression: exp.Parameter) -> str:
618            this = self.sql(expression, "this")
619            expression_sql = self.sql(expression, "expression")
620
621            parent = expression.parent
622            this = f"{this}:{expression_sql}" if expression_sql else this
623
624            if isinstance(parent, exp.EQ) and isinstance(parent.parent, exp.SetItem):
625                # We need to produce SET key = value instead of SET ${key} = value
626                return this
627
628            return f"${{{this}}}"
def schema_sql(self, expression: sqlglot.expressions.Schema) -> str:
630        def schema_sql(self, expression: exp.Schema) -> str:
631            for ordered in expression.find_all(exp.Ordered):
632                if ordered.args.get("desc") is False:
633                    ordered.set("desc", None)
634
635            return super().schema_sql(expression)
def constraint_sql(self, expression: sqlglot.expressions.Constraint) -> str:
637        def constraint_sql(self, expression: exp.Constraint) -> str:
638            for prop in list(expression.find_all(exp.Properties)):
639                prop.pop()
640
641            this = self.sql(expression, "this")
642            expressions = self.expressions(expression, sep=" ", flat=True)
643            return f"CONSTRAINT {this} {expressions}"
def rowformatserdeproperty_sql(self, expression: sqlglot.expressions.RowFormatSerdeProperty) -> str:
645        def rowformatserdeproperty_sql(self, expression: exp.RowFormatSerdeProperty) -> str:
646            serde_props = self.sql(expression, "serde_properties")
647            serde_props = f" {serde_props}" if serde_props else ""
648            return f"ROW FORMAT SERDE {self.sql(expression, 'this')}{serde_props}"
def arrayagg_sql(self, expression: sqlglot.expressions.ArrayAgg) -> str:
650        def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
651            return self.func(
652                "COLLECT_LIST",
653                expression.this.this if isinstance(expression.this, exp.Order) else expression.this,
654            )
def datatype_sql(self, expression: sqlglot.expressions.DataType) -> str:
656        def datatype_sql(self, expression: exp.DataType) -> str:
657            if expression.this in self.PARAMETERIZABLE_TEXT_TYPES and (
658                not expression.expressions or expression.expressions[0].name == "MAX"
659            ):
660                expression = exp.DataType.build("text")
661            elif expression.is_type(exp.DataType.Type.TEXT) and expression.expressions:
662                expression.set("this", exp.DataType.Type.VARCHAR)
663            elif expression.this in exp.DataType.TEMPORAL_TYPES:
664                expression = exp.DataType.build(expression.this)
665            elif expression.is_type("float"):
666                size_expression = expression.find(exp.DataTypeParam)
667                if size_expression:
668                    size = int(size_expression.name)
669                    expression = (
670                        exp.DataType.build("float") if size <= 32 else exp.DataType.build("double")
671                    )
672
673            return super().datatype_sql(expression)
def version_sql(self, expression: sqlglot.expressions.Version) -> str:
675        def version_sql(self, expression: exp.Version) -> str:
676            sql = super().version_sql(expression)
677            return sql.replace("FOR ", "", 1)
def struct_sql(self, expression: sqlglot.expressions.Struct) -> str:
679        def struct_sql(self, expression: exp.Struct) -> str:
680            values = []
681
682            for i, e in enumerate(expression.expressions):
683                if isinstance(e, exp.PropertyEQ):
684                    self.unsupported("Hive does not support named structs.")
685                    values.append(e.expression)
686                else:
687                    values.append(e)
688
689            return self.func("STRUCT", *values)
def alterset_sql(self, expression: sqlglot.expressions.AlterSet) -> str:
691        def alterset_sql(self, expression: exp.AlterSet) -> str:
692            exprs = self.expressions(expression, flat=True)
693            exprs = f" {exprs}" if exprs else ""
694            location = self.sql(expression, "location")
695            location = f" LOCATION {location}" if location else ""
696            file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
697            file_format = f" FILEFORMAT {file_format}" if file_format else ""
698            serde = self.sql(expression, "serde")
699            serde = f" SERDE {serde}" if serde else ""
700            tags = self.expressions(expression, key="tag", flat=True, sep="")
701            tags = f" TAGS {tags}" if tags else ""
702
703            return f"SET{serde}{exprs}{location}{file_format}{tags}"
def serdeproperties_sql(self, expression: sqlglot.expressions.SerdeProperties) -> str:
705        def serdeproperties_sql(self, expression: exp.SerdeProperties) -> str:
706            prefix = "WITH " if expression.args.get("with") else ""
707            exprs = self.expressions(expression, flat=True)
708
709            return f"{prefix}SERDEPROPERTIES ({exprs})"
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
TIME_PART_SINGULARS
AFTER_HAVING_MODIFIER_TRANSFORMS
TOKEN_MAPPING
STRUCT_DELIMITER
PARAMETER_TOKEN
NAMED_PLACEHOLDER_TOKEN
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
exists_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
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
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
merge_sql
tochar_sql
tonumber_sql
dictproperty_sql
dictrange_sql
dictsubproperty_sql
duplicatekeyproperty_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
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
jsonexists_sql
apply_sql
grant_sql
grantprivilege_sql
grantprincipal_sql
columns_sql
overlay_sql