sqlglot.generators.hive

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