sqlglot.generators.hive

  1from __future__ import annotations
  2
  3import re
  4from functools import partial
  5
  6from sqlglot import exp, generator, transforms
  7from sqlglot.dialects.dialect import (
  8    DATE_ADD_OR_SUB,
  9    approx_count_distinct_sql,
 10    arg_max_or_min_no_count,
 11    datestrtodate_sql,
 12    if_sql,
 13    left_to_substring_sql,
 14    max_or_greatest,
 15    min_or_least,
 16    no_ilike_sql,
 17    no_recursive_cte_sql,
 18    no_trycast_sql,
 19    regexp_extract_sql,
 20    regexp_replace_sql,
 21    rename_func,
 22    right_to_substring_sql,
 23    strposition_sql,
 24    struct_extract_sql,
 25    time_format,
 26    timestrtotime_sql,
 27    trim_sql,
 28    weekstart_unit_to_str,
 29    var_map_sql,
 30    sequence_sql,
 31    property_sql,
 32)
 33from sqlglot.transforms import (
 34    remove_unique_constraints,
 35    ctas_with_tmp_tables_to_create_tmp_view,
 36    preprocess,
 37    move_schema_columns_to_partitioned_by,
 38)
 39from sqlglot.generator import unsupported_args
 40from sqlglot.time import format_time
 41
 42# These constants are duplicated from the Hive dialect class to avoid circular imports.
 43# They must be kept in sync with Hive.TIME_FORMAT, Hive.DATE_FORMAT, Hive.DATEINT_FORMAT.
 44HIVE_TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"
 45HIVE_DATE_FORMAT = "'yyyy-MM-dd'"
 46HIVE_DATEINT_FORMAT = "'yyyyMMdd'"
 47
 48# The default formats above, as rendered by the lenient rewrite (non-padded month/day/time)
 49HIVE_NON_PADDED_TIME_FORMATS = ("'yyyy-M-d H:m:s'", "'yyyy-M-d'")
 50
 51# Expressions that parse a string with a format (vs. formatting one, like TimeToStr).
 52PARSE_TIME_EXPRESSIONS = (exp.StrToTime, exp.StrToDate, exp.StrToUnix, exp.TsOrDsToDate)
 53
 54CANONICAL_TIME_FORMAT = re.compile(r"%(?:[mdHIMS]strict|[-:].|.)")
 55
 56LAX_TO_NON_PADDED_FORMATS = {
 57    "%m": "%-m",
 58    "%d": "%-d",
 59    "%H": "%-H",
 60    "%I": "%-I",
 61    "%M": "%-M",
 62    "%S": "%-S",
 63}
 64
 65
 66def _lenient_parse_format(fmt: str) -> str:
 67    """
 68    Changes a lax month/day/hour/minute/second in a canonical format to its non-padded form
 69    (e.g. %m -> %-m), which java.time parses with or without a leading zero. This is only safe
 70    for delimited specifiers, because adjacent fields parse greedily, so e.g. 'yyyyMd' (from
 71    '%Y%m%d') can't even parse '20200101'.
 72
 73    The format is decomposed into specifiers (`formats`) and the interleaved literal text (`parts`).
 74    Specifier i sits between parts[i] and parts[i + 1]. A specifier is changed only when its
 75    neighbors don't touch a digit run, i.e., neither side is another specifier or a literal digit.
 76    At the end, the pieces are zipped back together to produce the rewritten canonical format.
 77    """
 78    parts = CANONICAL_TIME_FORMAT.split(fmt)
 79    formats = CANONICAL_TIME_FORMAT.findall(fmt)
 80
 81    for i, fmt_ in enumerate(formats):
 82        if fmt_ in LAX_TO_NON_PADDED_FORMATS:
 83            left, right = parts[i], parts[i + 1]
 84            left_adjacent = (not left and i > 0) or (left and left[-1].isdigit())
 85            right_adjacent = (not right and i < len(formats) - 1) or (right and right[0].isdigit())
 86            if not left_adjacent and not right_adjacent:
 87                formats[i] = LAX_TO_NON_PADDED_FORMATS[fmt_]
 88
 89    return "".join(part + fmt_ for part, fmt_ in zip(parts, formats + [""]))
 90
 91
 92# (FuncType, Multiplier)
 93DATE_DELTA_INTERVAL = {
 94    "YEAR": ("ADD_MONTHS", 12),
 95    "MONTH": ("ADD_MONTHS", 1),
 96    "QUARTER": ("ADD_MONTHS", 3),
 97    "WEEK": ("DATE_ADD", 7),
 98    "DAY": ("DATE_ADD", 1),
 99}
100
101TIME_DIFF_FACTOR = {
102    "MILLISECOND": " * 1000",
103    "SECOND": "",
104    "MINUTE": " / 60",
105    "HOUR": " / 3600",
106}
107
108DIFF_MONTH_SWITCH = ("YEAR", "QUARTER", "MONTH")
109
110HIVE_TS_OR_DS_EXPRESSIONS: tuple[type[exp.Expr], ...] = (
111    exp.DateDiff,
112    exp.Day,
113    exp.Month,
114    exp.Year,
115)
116
117
118def _add_date_sql(self: HiveGenerator, expression: DATE_ADD_OR_SUB) -> str:
119    if isinstance(expression, exp.TsOrDsAdd) and not expression.unit:
120        return self.func("DATE_ADD", expression.this, expression.expression)
121
122    unit = expression.text("unit").upper()
123    func, multiplier = DATE_DELTA_INTERVAL.get(unit, ("DATE_ADD", 1))
124
125    if isinstance(expression, exp.DateSub):
126        multiplier *= -1
127
128    increment = expression.expression
129    if isinstance(increment, exp.Literal):
130        value = increment.to_py() if increment.is_number else int(increment.name)
131        increment = exp.Literal.number(value * multiplier)
132    elif multiplier != 1:
133        increment *= exp.Literal.number(multiplier)
134
135    return self.func(func, expression.this, increment)
136
137
138def _date_diff_sql(self: HiveGenerator, expression: exp.DateDiff | exp.TsOrDsDiff) -> str:
139    unit = expression.text("unit").upper()
140
141    factor = TIME_DIFF_FACTOR.get(unit)
142    if factor is not None:
143        left = self.sql(expression, "this")
144        right = self.sql(expression, "expression")
145        sec_diff = f"UNIX_TIMESTAMP({left}) - UNIX_TIMESTAMP({right})"
146        return f"({sec_diff}){factor}" if factor else sec_diff
147
148    months_between = unit in DIFF_MONTH_SWITCH
149    sql_func = "MONTHS_BETWEEN" if months_between else "DATEDIFF"
150    _, multiplier = DATE_DELTA_INTERVAL.get(unit, ("", 1))
151    multiplier_sql = f" / {multiplier}" if multiplier > 1 else ""
152    diff_sql = f"{sql_func}({self.format_args(expression.this, expression.expression)})"
153
154    if months_between or multiplier_sql:
155        # MONTHS_BETWEEN returns a float, so we need to truncate the fractional part.
156        # For the same reason, we want to truncate if there's a divisor present.
157        diff_sql = f"CAST({diff_sql}{multiplier_sql} AS INT)"
158
159    return diff_sql
160
161
162@generator.unsupported_args(("expression", "Hive's SORT_ARRAY does not support a comparator."))
163def _array_sort_sql(self: HiveGenerator, expression: exp.ArraySort) -> str:
164    return self.func("SORT_ARRAY", expression.this)
165
166
167def _str_to_unix_sql(self: HiveGenerator, expression: exp.StrToUnix) -> str:
168    return self.func("UNIX_TIMESTAMP", expression.this, time_format("hive")(self, expression))
169
170
171def _unix_to_time_sql(self: HiveGenerator, expression: exp.UnixToTime) -> str:
172    timestamp = self.sql(expression, "this")
173    scale = expression.args.get("scale")
174    if scale in (None, exp.UnixToTime.SECONDS):
175        return rename_func("FROM_UNIXTIME")(self, expression)
176
177    return f"FROM_UNIXTIME({timestamp} / POW(10, {scale}))"
178
179
180def _is_cast_time_format(self: HiveGenerator, expression: exp.Expr, time_format: str) -> bool:
181    """Checks whether CAST subsumes the expression's parse format."""
182    if time_format in (HIVE_TIME_FORMAT, HIVE_DATE_FORMAT):
183        return True
184
185    if time_format in HIVE_NON_PADDED_TIME_FORMATS:
186        # The base render skips the lenient rewrite: a lax specifier pads back (e.g. %m -> MM),
187        # an explicit non-padded specifier (e.g. %-m) doesn't
188        padded_format = generator.Generator.format_time(self, expression)
189        return padded_format in (HIVE_TIME_FORMAT, HIVE_DATE_FORMAT)
190
191    return False
192
193
194def _str_to_date_sql(self: HiveGenerator, expression: exp.StrToDate) -> str:
195    this = self.sql(expression, "this")
196    time_format = self.format_time(expression)
197    if time_format and not _is_cast_time_format(self, expression, time_format):
198        this = f"FROM_UNIXTIME(UNIX_TIMESTAMP({this}, {time_format}))"
199    return f"CAST({this} AS DATE)"
200
201
202def _str_to_time_sql(self: HiveGenerator, expression: exp.StrToTime) -> str:
203    this = self.sql(expression, "this")
204    time_format = self.format_time(expression)
205    if time_format and not _is_cast_time_format(self, expression, time_format):
206        this = f"FROM_UNIXTIME(UNIX_TIMESTAMP({this}, {time_format}))"
207    return f"CAST({this} AS TIMESTAMP)"
208
209
210def _to_date_sql(self: HiveGenerator, expression: exp.TsOrDsToDate) -> str:
211    time_format = self.format_time(expression)
212    if time_format and not _is_cast_time_format(self, expression, time_format):
213        return self.func("TO_DATE", expression.this, time_format)
214
215    if isinstance(expression.parent, self.TS_OR_DS_EXPRESSIONS):
216        return self.sql(expression, "this")
217
218    return self.func("TO_DATE", expression.this)
219
220
221class HiveGenerator(generator.Generator):
222    SELECT_KINDS: tuple[str, ...] = ()
223    TRY_SUPPORTED = False
224    SUPPORTS_UESCAPE = False
225    SUPPORTS_DECODE_CASE = False
226    LIMIT_FETCH = "LIMIT"
227    TABLESAMPLE_WITH_METHOD = False
228    JOIN_HINTS = False
229    TABLE_HINTS = False
230    QUERY_HINTS = False
231    INDEX_ON = "ON TABLE"
232    EXTRACT_ALLOWS_QUOTES = False
233    NVL2_SUPPORTED = False
234    LAST_DAY_SUPPORTS_DATE_PART = False
235    JSON_PATH_SINGLE_QUOTE_ESCAPE = True
236    SAFE_JSON_PATH_KEY_RE = re.compile(r"^[_\-a-zA-Z][\-\w]*$")
237    SUPPORTS_TO_NUMBER = False
238    WITH_PROPERTIES_PREFIX = "TBLPROPERTIES"
239    PARSE_JSON_NAME: str | None = "PARSE_JSON"
240    PAD_FILL_PATTERN_IS_REQUIRED = True
241    SUPPORTS_MEDIAN = False
242    ARRAY_SIZE_NAME = "SIZE"
243    ALTER_SET_TYPE = ""
244
245    EXPRESSIONS_WITHOUT_NESTED_CTES = {
246        exp.Insert,
247        exp.Select,
248        exp.Subquery,
249        exp.SetOperation,
250    }
251
252    SUPPORTED_JSON_PATH_PARTS = {
253        exp.JSONPathKey,
254        exp.JSONPathRoot,
255        exp.JSONPathSubscript,
256        exp.JSONPathWildcard,
257    }
258
259    TYPE_MAPPING = {
260        **generator.Generator.TYPE_MAPPING,
261        exp.DType.BIT: "BOOLEAN",
262        exp.DType.BLOB: "BINARY",
263        exp.DType.DATETIME: "TIMESTAMP",
264        exp.DType.ROWVERSION: "BINARY",
265        exp.DType.TEXT: "STRING",
266        exp.DType.TIME: "TIMESTAMP",
267        exp.DType.TIMESTAMPNTZ: "TIMESTAMP",
268        exp.DType.TIMESTAMPTZ: "TIMESTAMP",
269        exp.DType.UTINYINT: "SMALLINT",
270        exp.DType.VARBINARY: "BINARY",
271    }
272
273    TRANSFORMS = {
274        **generator.Generator.TRANSFORMS,
275        exp.Property: property_sql,
276        exp.AnyValue: rename_func("FIRST"),
277        exp.ApproxDistinct: approx_count_distinct_sql,
278        exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
279        exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
280        exp.Array: transforms.preprocess([transforms.inherit_struct_field_names]),
281        exp.ArrayConcat: rename_func("CONCAT"),
282        exp.ArrayToString: lambda self, e: self.func("CONCAT_WS", e.expression, e.this),
283        exp.ArraySort: _array_sort_sql,
284        exp.With: no_recursive_cte_sql,
285        exp.DateAdd: _add_date_sql,
286        exp.DateDiff: _date_diff_sql,
287        exp.DateStrToDate: datestrtodate_sql,
288        exp.DateSub: _add_date_sql,
289        exp.DateToDi: lambda self, e: (
290            f"CAST(DATE_FORMAT({self.sql(e, 'this')}, {HIVE_DATEINT_FORMAT}) AS INT)"
291        ),
292        exp.DiToDate: lambda self, e: (
293            f"TO_DATE(CAST({self.sql(e, 'this')} AS STRING), {HIVE_DATEINT_FORMAT})"
294        ),
295        exp.StorageHandlerProperty: lambda self, e: f"STORED BY {self.sql(e, 'this')}",
296        exp.FromBase64: rename_func("UNBASE64"),
297        exp.GenerateSeries: sequence_sql,
298        exp.GenerateDateArray: sequence_sql,
299        exp.If: if_sql(),
300        exp.ILike: no_ilike_sql,
301        exp.IntDiv: lambda self, e: self.binary(e, "DIV"),
302        exp.IsNan: rename_func("ISNAN"),
303        exp.JSONExtract: lambda self, e: self.func("GET_JSON_OBJECT", e.this, e.expression),
304        exp.JSONExtractScalar: lambda self, e: self.func("GET_JSON_OBJECT", e.this, e.expression),
305        exp.JSONFormat: rename_func("TO_JSON"),
306        exp.Left: left_to_substring_sql,
307        exp.Map: var_map_sql,
308        exp.Max: max_or_greatest,
309        exp.MD5Digest: lambda self, e: self.func("UNHEX", self.func("MD5", e.this)),
310        exp.Min: min_or_least,
311        exp.MonthsBetween: lambda self, e: self.func("MONTHS_BETWEEN", e.this, e.expression),
312        exp.NotNullColumnConstraint: lambda _, e: "" if e.args.get("allow_null") else "NOT NULL",
313        exp.VarMap: var_map_sql,
314        exp.Create: preprocess(
315            [
316                remove_unique_constraints,
317                ctas_with_tmp_tables_to_create_tmp_view,
318                move_schema_columns_to_partitioned_by,
319            ]
320        ),
321        exp.Quantile: rename_func("PERCENTILE"),
322        exp.ApproxQuantile: rename_func("PERCENTILE_APPROX"),
323        exp.RegexpExtract: regexp_extract_sql,
324        exp.RegexpExtractAll: regexp_extract_sql,
325        exp.RegexpReplace: regexp_replace_sql,
326        exp.RegexpLike: lambda self, e: self.binary(e, "RLIKE"),
327        exp.RegexpSplit: rename_func("SPLIT"),
328        exp.Right: right_to_substring_sql,
329        exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
330        exp.ArrayUniqueAgg: rename_func("COLLECT_SET"),
331        exp.Split: lambda self, e: self.func(
332            "SPLIT", e.this, self.func("CONCAT", "'\\\\Q'", e.expression, "'\\\\E'")
333        ),
334        exp.Select: transforms.preprocess(
335            [
336                transforms.eliminate_qualify,
337                transforms.eliminate_distinct_on,
338                partial(transforms.unnest_to_explode, unnest_using_arrays_zip=False),
339                transforms.any_to_exists,
340            ]
341        ),
342        exp.StrPosition: lambda self, e: strposition_sql(
343            self, e, func_name="LOCATE", supports_position=True
344        ),
345        exp.StrToDate: _str_to_date_sql,
346        exp.StrToTime: _str_to_time_sql,
347        exp.StrToUnix: _str_to_unix_sql,
348        exp.StructExtract: struct_extract_sql,
349        exp.StarMap: rename_func("MAP"),
350        exp.Table: transforms.preprocess([transforms.unnest_generate_series]),
351        exp.TimeStrToDate: rename_func("TO_DATE"),
352        exp.TimeStrToTime: timestrtotime_sql,
353        exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
354        exp.TimestampTrunc: lambda self, e: self.func(
355            "TRUNC", e.this, weekstart_unit_to_str(self, e)
356        ),
357        exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"),
358        exp.ToBase64: rename_func("BASE64"),
359        exp.TsOrDiToDi: lambda self, e: (
360            f"CAST(SUBSTR(REPLACE(CAST({self.sql(e, 'this')} AS STRING), '-', ''), 1, 8) AS INT)"
361        ),
362        exp.TsOrDsAdd: _add_date_sql,
363        exp.TsOrDsDiff: _date_diff_sql,
364        exp.TsOrDsToDate: _to_date_sql,
365        exp.TryCast: no_trycast_sql,
366        exp.Trim: trim_sql,
367        exp.Unicode: rename_func("ASCII"),
368        exp.UnixToStr: lambda self, e: self.func(
369            "FROM_UNIXTIME", e.this, time_format("hive")(self, e)
370        ),
371        exp.UnixToTime: _unix_to_time_sql,
372        exp.UnixToTimeStr: rename_func("FROM_UNIXTIME"),
373        exp.Unnest: rename_func("EXPLODE"),
374        exp.PartitionedByProperty: lambda self, e: f"PARTITIONED BY {self.sql(e, 'this')}",
375        exp.NumberToStr: rename_func("FORMAT_NUMBER"),
376        exp.National: lambda self, e: self.national_sql(e, prefix=""),
377        exp.ClusteredColumnConstraint: lambda self, e: (
378            f"({self.expressions(e, 'this', indent=False)})"
379        ),
380        exp.NonClusteredColumnConstraint: lambda self, e: (
381            f"({self.expressions(e, 'this', indent=False)})"
382        ),
383        exp.NotForReplicationColumnConstraint: lambda *_: "",
384        exp.OnProperty: lambda *_: "",
385        exp.PartitionedByBucket: lambda self, e: self.func("BUCKET", e.expression, e.this),
386        exp.PartitionByTruncate: lambda self, e: self.func("TRUNCATE", e.expression, e.this),
387        exp.PrimaryKeyColumnConstraint: lambda *_: "PRIMARY KEY",
388        exp.WeekOfYear: rename_func("WEEKOFYEAR"),
389        exp.DayOfMonth: rename_func("DAYOFMONTH"),
390        exp.DayOfWeek: rename_func("DAYOFWEEK"),
391        exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
392            rename_func("LEVENSHTEIN")
393        ),
394    }
395
396    PROPERTIES_LOCATION = {
397        **generator.Generator.PROPERTIES_LOCATION,
398        exp.FileFormatProperty: exp.Properties.Location.POST_SCHEMA,
399        exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
400        exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
401        exp.WithDataProperty: exp.Properties.Location.UNSUPPORTED,
402    }
403
404    TS_OR_DS_EXPRESSIONS = HIVE_TS_OR_DS_EXPRESSIONS
405
406    IGNORE_NULLS_FUNCS = (exp.First, exp.Last, exp.FirstValue, exp.LastValue)
407
408    def format_time(
409        self,
410        expression: exp.Expr,
411        inverse_time_mapping: dict[str, str] | None = None,
412        inverse_time_trie: dict | None = None,
413    ) -> str | None:
414        # Inferred property because this method is reused by other dialects under Hive
415        is_dialect_strict = self.dialect.TIME_MAPPING.get("MM") == "%mstrict"
416
417        if (
418            is_dialect_strict
419            and inverse_time_mapping is None
420            and isinstance(expression, PARSE_TIME_EXPRESSIONS)
421        ):
422            # Render a lenient %m/%d non-padded (M/d) so single-digit sources stay parseable
423            return format_time(
424                _lenient_parse_format(self.sql(expression, "format")),
425                self.dialect.INVERSE_TIME_MAPPING,
426                self.dialect.INVERSE_TIME_TRIE,
427            )
428
429        return super().format_time(expression, inverse_time_mapping, inverse_time_trie)
430
431    def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
432        this = expression.this
433        if isinstance(this, self.IGNORE_NULLS_FUNCS):
434            return self.func(this.sql_name(), this.this, exp.true())
435
436        return super().ignorenulls_sql(expression)
437
438    def unnest_sql(self, expression: exp.Unnest) -> str:
439        return rename_func("EXPLODE")(self, expression)
440
441    def _jsonpathkey_sql(self, expression: exp.JSONPathKey) -> str:
442        if isinstance(expression.this, exp.JSONPathWildcard):
443            self.unsupported("Unsupported wildcard in JSONPathKey expression")
444            return ""
445
446        return super()._jsonpathkey_sql(expression)
447
448    def parameter_sql(self, expression: exp.Parameter) -> str:
449        this = self.sql(expression, "this")
450        expression_sql = self.sql(expression, "expression")
451
452        parent = expression.parent
453        this = f"{this}:{expression_sql}" if expression_sql else this
454
455        if isinstance(parent, exp.EQ) and isinstance(parent.parent, exp.SetItem):
456            # We need to produce SET key = value instead of SET ${key} = value
457            return this
458
459        return f"${{{this}}}"
460
461    def schema_sql(self, expression: exp.Schema) -> str:
462        for ordered in expression.find_all(exp.Ordered):
463            if ordered.args.get("desc") is False:
464                ordered.set("desc", None)
465
466        return super().schema_sql(expression)
467
468    def constraint_sql(self, expression: exp.Constraint) -> str:
469        for prop in list(expression.find_all(exp.Properties)):
470            prop.pop()
471
472        this = self.sql(expression, "this")
473        expressions = self.expressions(expression, sep=" ", flat=True)
474        return f"CONSTRAINT {this} {expressions}"
475
476    def rowformatserdeproperty_sql(self, expression: exp.RowFormatSerdeProperty) -> str:
477        serde_props = self.sql(expression, "serde_properties")
478        serde_props = f" {serde_props}" if serde_props else ""
479        return f"ROW FORMAT SERDE {self.sql(expression, 'this')}{serde_props}"
480
481    def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
482        return self.func(
483            "COLLECT_LIST",
484            expression.this.this if isinstance(expression.this, exp.Order) else expression.this,
485        )
486
487    # Hive/Spark lack native numeric TRUNC. CAST to BIGINT truncates toward zero (not rounds).
488    # Potential enhancement: a TRUNC_TEMPLATE using FLOOR/CEIL with scale (Spark 3.3+)
489    # could preserve decimals: CASE WHEN x >= 0 THEN FLOOR(x, d) ELSE CEIL(x, d) END
490    @unsupported_args("decimals")
491    def trunc_sql(self, expression: exp.Trunc) -> str:
492        return self.sql(exp.cast(expression.this, exp.DType.BIGINT))
493
494    def datatype_sql(self, expression: exp.DataType) -> str:
495        if expression.this in self.PARAMETERIZABLE_TEXT_TYPES and (
496            not expression.expressions or expression.expressions[0].name == "MAX"
497        ):
498            expression.set("this", exp.DType.TEXT)
499            expression.set("expressions", None)
500        elif expression.is_type(exp.DType.TEXT) and expression.expressions:
501            expression.set("this", exp.DType.VARCHAR)
502        elif expression.this in exp.DataType.TEMPORAL_TYPES:
503            expression.set("expressions", None)
504        elif expression.is_type("float"):
505            size_expression = expression.find(exp.DataTypeParam)
506            if size_expression:
507                size = int(size_expression.name)
508                expression.set("this", exp.DType.FLOAT if size <= 32 else exp.DType.DOUBLE)
509                expression.set("expressions", None)
510        return super().datatype_sql(expression)
511
512    def version_sql(self, expression: exp.Version) -> str:
513        sql = super().version_sql(expression)
514        return sql.replace("FOR ", "", 1)
515
516    def struct_sql(self, expression: exp.Struct) -> str:
517        values = []
518
519        for i, e in enumerate(expression.expressions):
520            if isinstance(e, exp.PropertyEQ):
521                self.unsupported("Hive does not support named structs.")
522                values.append(e.expression)
523            else:
524                values.append(e)
525
526        return self.func("STRUCT", *values)
527
528    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
529        return super().columndef_sql(
530            expression,
531            sep=(
532                ": "
533                if isinstance(expression.parent, exp.DataType)
534                and expression.parent.is_type("struct")
535                else sep
536            ),
537        )
538
539    def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
540        this = self.sql(expression, "this")
541        new_name = self.sql(expression, "rename_to") or this
542        dtype = self.sql(expression, "dtype")
543        comment = (
544            f" COMMENT {self.sql(expression, 'comment')}" if self.sql(expression, "comment") else ""
545        )
546        default = self.sql(expression, "default")
547        visible = expression.args.get("visible")
548        allow_null = expression.args.get("allow_null")
549        drop = expression.args.get("drop")
550
551        if any([default, drop, visible, allow_null, drop]):
552            self.unsupported("Unsupported CHANGE COLUMN syntax")
553
554        if not dtype:
555            self.unsupported("CHANGE COLUMN without a type is not supported")
556
557        return f"CHANGE COLUMN {this} {new_name} {dtype}{comment}"
558
559    def renamecolumn_sql(self, expression: exp.RenameColumn) -> str:
560        self.unsupported("Cannot rename columns without data type defined in Hive")
561        return ""
562
563    def alterset_sql(self, expression: exp.AlterSet) -> str:
564        exprs = self.expressions(expression, flat=True)
565        exprs = f" {exprs}" if exprs else ""
566        location = self.sql(expression, "location")
567        location = f" LOCATION {location}" if location else ""
568        file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
569        file_format = f" FILEFORMAT {file_format}" if file_format else ""
570        serde = self.sql(expression, "serde")
571        serde = f" SERDE {serde}" if serde else ""
572        tags = self.expressions(expression, key="tag", flat=True, sep="")
573        tags = f" TAGS {tags}" if tags else ""
574
575        return f"SET{serde}{exprs}{location}{file_format}{tags}"
576
577    def serdeproperties_sql(self, expression: exp.SerdeProperties) -> str:
578        prefix = "WITH " if expression.args.get("with_") else ""
579        exprs = self.expressions(expression, flat=True)
580
581        return f"{prefix}SERDEPROPERTIES ({exprs})"
582
583    def exists_sql(self, expression: exp.Exists) -> str:
584        if expression.expression:
585            return self.function_fallback_sql(expression)
586
587        return super().exists_sql(expression)
588
589    def timetostr_sql(self, expression: exp.TimeToStr) -> str:
590        this = expression.this
591        if isinstance(this, exp.TimeStrToTime):
592            this = this.this
593
594        return self.func("DATE_FORMAT", this, self.format_time(expression))
595
596    def usingproperty_sql(self, expression: exp.UsingProperty) -> str:
597        kind = expression.args.get("kind")
598        return f"USING {kind} {self.sql(expression, 'this')}"
599
600    def fileformatproperty_sql(self, expression: exp.FileFormatProperty) -> str:
601        if isinstance(expression.this, exp.InputOutputFormat):
602            this = self.sql(expression, "this")
603        else:
604            this = expression.name.upper()
605
606        return f"STORED AS {this}"