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    ARRAY_SIZE_NAME = "SIZE"
250    ALTER_SET_TYPE = ""
251
252    EXPRESSIONS_WITHOUT_NESTED_CTES = {
253        exp.Insert,
254        exp.Select,
255        exp.Subquery,
256        exp.SetOperation,
257    }
258
259    SUPPORTED_JSON_PATH_PARTS = {
260        exp.JSONPathKey,
261        exp.JSONPathRoot,
262        exp.JSONPathSubscript,
263        exp.JSONPathWildcard,
264    }
265
266    TYPE_MAPPING = {
267        **generator.Generator.TYPE_MAPPING,
268        exp.DType.BIT: "BOOLEAN",
269        exp.DType.BLOB: "BINARY",
270        exp.DType.DATETIME: "TIMESTAMP",
271        exp.DType.ROWVERSION: "BINARY",
272        exp.DType.TEXT: "STRING",
273        exp.DType.TIME: "TIMESTAMP",
274        exp.DType.TIMESTAMPNTZ: "TIMESTAMP",
275        exp.DType.TIMESTAMPTZ: "TIMESTAMP",
276        exp.DType.UTINYINT: "SMALLINT",
277        exp.DType.VARBINARY: "BINARY",
278    }
279
280    TRANSFORMS = {
281        **generator.Generator.TRANSFORMS,
282        exp.Property: property_sql,
283        exp.AnyValue: rename_func("FIRST"),
284        exp.ApproxDistinct: approx_count_distinct_sql,
285        exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
286        exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
287        exp.Array: transforms.preprocess([transforms.inherit_struct_field_names]),
288        exp.ArrayConcat: rename_func("CONCAT"),
289        exp.ArrayToString: lambda self, e: self.func("CONCAT_WS", e.expression, e.this),
290        exp.ArraySort: _array_sort_sql,
291        exp.With: no_recursive_cte_sql,
292        exp.DateAdd: _add_date_sql,
293        exp.DateDiff: _date_diff_sql,
294        exp.DateStrToDate: datestrtodate_sql,
295        exp.DateSub: _add_date_sql,
296        exp.DateToDi: lambda self, e: (
297            f"CAST(DATE_FORMAT({self.sql(e, 'this')}, {HIVE_DATEINT_FORMAT}) AS INT)"
298        ),
299        exp.DiToDate: lambda self, e: (
300            f"TO_DATE(CAST({self.sql(e, 'this')} AS STRING), {HIVE_DATEINT_FORMAT})"
301        ),
302        exp.StorageHandlerProperty: lambda self, e: f"STORED BY {self.sql(e, 'this')}",
303        exp.FromBase64: rename_func("UNBASE64"),
304        exp.GenerateSeries: sequence_sql,
305        exp.GenerateDateArray: sequence_sql,
306        exp.If: if_sql(),
307        exp.ILike: no_ilike_sql,
308        exp.IntDiv: lambda self, e: self.binary(e, "DIV"),
309        exp.IsNan: rename_func("ISNAN"),
310        exp.JSONExtract: lambda self, e: self.func("GET_JSON_OBJECT", e.this, e.expression),
311        exp.JSONExtractScalar: lambda self, e: self.func("GET_JSON_OBJECT", e.this, e.expression),
312        exp.JSONFormat: rename_func("TO_JSON"),
313        exp.Left: left_to_substring_sql,
314        exp.Map: var_map_sql,
315        exp.Max: max_or_greatest,
316        exp.MD5Digest: lambda self, e: self.func("UNHEX", self.func("MD5", e.this)),
317        exp.Min: min_or_least,
318        exp.MonthsBetween: lambda self, e: self.func("MONTHS_BETWEEN", e.this, e.expression),
319        exp.NotNullColumnConstraint: lambda _, e: "" if e.args.get("allow_null") else "NOT NULL",
320        exp.VarMap: var_map_sql,
321        exp.Create: preprocess(
322            [
323                remove_unique_constraints,
324                ctas_with_tmp_tables_to_create_tmp_view,
325                move_schema_columns_to_partitioned_by,
326            ]
327        ),
328        exp.Quantile: rename_func("PERCENTILE"),
329        exp.ApproxQuantile: rename_func("PERCENTILE_APPROX"),
330        exp.RegexpExtract: regexp_extract_sql,
331        exp.RegexpExtractAll: regexp_extract_sql,
332        exp.RegexpReplace: regexp_replace_sql,
333        exp.RegexpLike: lambda self, e: self.binary(e, "RLIKE"),
334        exp.RegexpSplit: rename_func("SPLIT"),
335        exp.Right: right_to_substring_sql,
336        exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
337        exp.ArrayUniqueAgg: rename_func("COLLECT_SET"),
338        exp.Split: lambda self, e: self.func(
339            "SPLIT", e.this, self.func("CONCAT", "'\\\\Q'", e.expression, "'\\\\E'")
340        ),
341        exp.Select: transforms.preprocess(
342            [
343                transforms.eliminate_qualify,
344                transforms.eliminate_distinct_on,
345                partial(transforms.unnest_to_explode, unnest_using_arrays_zip=False),
346                transforms.any_to_exists,
347            ]
348        ),
349        exp.StrPosition: lambda self, e: strposition_sql(
350            self, e, func_name="LOCATE", supports_position=True
351        ),
352        exp.StrToDate: _str_to_date_sql,
353        exp.StrToTime: _str_to_time_sql,
354        exp.StrToUnix: _str_to_unix_sql,
355        exp.StructExtract: struct_extract_sql,
356        exp.StarMap: rename_func("MAP"),
357        exp.Table: transforms.preprocess([transforms.unnest_generate_series]),
358        exp.TimeStrToDate: rename_func("TO_DATE"),
359        exp.TimeStrToTime: timestrtotime_sql,
360        exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
361        exp.TimestampTrunc: lambda self, e: self.func(
362            "TRUNC", e.this, weekstart_unit_to_str(self, e)
363        ),
364        exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"),
365        exp.ToBase64: rename_func("BASE64"),
366        exp.TsOrDiToDi: lambda self, e: (
367            f"CAST(SUBSTR(REPLACE(CAST({self.sql(e, 'this')} AS STRING), '-', ''), 1, 8) AS INT)"
368        ),
369        exp.TsOrDsAdd: _add_date_sql,
370        exp.TsOrDsDiff: _date_diff_sql,
371        exp.TsOrDsToDate: _to_date_sql,
372        exp.TryCast: no_trycast_sql,
373        exp.Trim: trim_sql,
374        exp.Unicode: rename_func("ASCII"),
375        exp.UnixToStr: lambda self, e: self.func(
376            "FROM_UNIXTIME", e.this, time_format("hive")(self, e)
377        ),
378        exp.UnixToTime: _unix_to_time_sql,
379        exp.UnixToTimeStr: rename_func("FROM_UNIXTIME"),
380        exp.Unnest: rename_func("EXPLODE"),
381        exp.PartitionedByProperty: lambda self, e: f"PARTITIONED BY {self.sql(e, 'this')}",
382        exp.NumberToStr: rename_func("FORMAT_NUMBER"),
383        exp.National: lambda self, e: self.national_sql(e, prefix=""),
384        exp.ClusteredColumnConstraint: lambda self, e: (
385            f"({self.expressions(e, 'this', indent=False)})"
386        ),
387        exp.NonClusteredColumnConstraint: lambda self, e: (
388            f"({self.expressions(e, 'this', indent=False)})"
389        ),
390        exp.NotForReplicationColumnConstraint: lambda *_: "",
391        exp.OnProperty: lambda *_: "",
392        exp.PartitionedByBucket: lambda self, e: self.func("BUCKET", e.expression, e.this),
393        exp.PartitionByTruncate: lambda self, e: self.func("TRUNCATE", e.expression, e.this),
394        exp.PrimaryKeyColumnConstraint: lambda *_: "PRIMARY KEY",
395        exp.WeekOfYear: rename_func("WEEKOFYEAR"),
396        exp.DayOfMonth: rename_func("DAYOFMONTH"),
397        exp.DayOfWeek: rename_func("DAYOFWEEK"),
398        exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
399            rename_func("LEVENSHTEIN")
400        ),
401    }
402
403    PROPERTIES_LOCATION = {
404        **generator.Generator.PROPERTIES_LOCATION,
405        exp.FileFormatProperty: exp.Properties.Location.POST_SCHEMA,
406        exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
407        exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
408        exp.WithDataProperty: exp.Properties.Location.UNSUPPORTED,
409    }
410
411    TS_OR_DS_EXPRESSIONS: t.ClassVar = HIVE_TS_OR_DS_EXPRESSIONS
412
413    IGNORE_NULLS_FUNCS: t.ClassVar = (exp.First, exp.Last, exp.FirstValue, exp.LastValue)
414
415    def format_time(
416        self,
417        expression: exp.Expr,
418        inverse_time_mapping: dict[str, str] | None = None,
419        inverse_time_trie: dict | None = None,
420    ) -> str | None:
421        # Inferred property because this method is reused by other dialects under Hive
422        is_dialect_strict = self.dialect.TIME_MAPPING.get("MM") == "%mstrict"
423
424        if (
425            is_dialect_strict
426            and inverse_time_mapping is None
427            and isinstance(expression, PARSE_TIME_EXPRESSIONS)
428        ):
429            # Render a lenient %m/%d non-padded (M/d) so single-digit sources stay parseable
430            return format_time(
431                _lenient_parse_format(self.sql(expression, "format")),
432                self.dialect.INVERSE_TIME_MAPPING,
433                self.dialect.INVERSE_TIME_TRIE,
434            )
435
436        return super().format_time(expression, inverse_time_mapping, inverse_time_trie)
437
438    def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
439        this = expression.this
440        if isinstance(this, self.IGNORE_NULLS_FUNCS):
441            return self.func(this.sql_name(), this.this, exp.true())
442
443        return super().ignorenulls_sql(expression)
444
445    def unnest_sql(self, expression: exp.Unnest) -> str:
446        return rename_func("EXPLODE")(self, expression)
447
448    def _jsonpathkey_sql(self, expression: exp.JSONPathKey) -> str:
449        if isinstance(expression.this, exp.JSONPathWildcard):
450            self.unsupported("Unsupported wildcard in JSONPathKey expression")
451            return ""
452
453        return super()._jsonpathkey_sql(expression)
454
455    def parameter_sql(self, expression: exp.Parameter) -> str:
456        this = self.sql(expression, "this")
457        expression_sql = self.sql(expression, "expression")
458
459        parent = expression.parent
460        this = f"{this}:{expression_sql}" if expression_sql else this
461
462        if isinstance(parent, exp.EQ) and isinstance(parent.parent, exp.SetItem):
463            # We need to produce SET key = value instead of SET ${key} = value
464            return this
465
466        return f"${{{this}}}"
467
468    def schema_sql(self, expression: exp.Schema) -> str:
469        for ordered in expression.find_all(exp.Ordered):
470            if ordered.args.get("desc") is False:
471                ordered.set("desc", None)
472
473        return super().schema_sql(expression)
474
475    def constraint_sql(self, expression: exp.Constraint) -> str:
476        for prop in list(expression.find_all(exp.Properties)):
477            prop.pop()
478
479        this = self.sql(expression, "this")
480        expressions = self.expressions(expression, sep=" ", flat=True)
481        return f"CONSTRAINT {this} {expressions}"
482
483    def rowformatserdeproperty_sql(self, expression: exp.RowFormatSerdeProperty) -> str:
484        serde_props = self.sql(expression, "serde_properties")
485        serde_props = f" {serde_props}" if serde_props else ""
486        return f"ROW FORMAT SERDE {self.sql(expression, 'this')}{serde_props}"
487
488    def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
489        return self.func(
490            "COLLECT_LIST",
491            expression.this.this if isinstance(expression.this, exp.Order) else expression.this,
492        )
493
494    # Hive/Spark lack native numeric TRUNC. CAST to BIGINT truncates toward zero (not rounds).
495    # Potential enhancement: a TRUNC_TEMPLATE using FLOOR/CEIL with scale (Spark 3.3+)
496    # could preserve decimals: CASE WHEN x >= 0 THEN FLOOR(x, d) ELSE CEIL(x, d) END
497    @unsupported_args("decimals")
498    def trunc_sql(self, expression: exp.Trunc) -> str:
499        return self.sql(exp.cast(expression.this, exp.DType.BIGINT))
500
501    def datatype_sql(self, expression: exp.DataType) -> str:
502        if expression.this in self.PARAMETERIZABLE_TEXT_TYPES and (
503            not expression.expressions or expression.expressions[0].name == "MAX"
504        ):
505            expression.set("this", exp.DType.TEXT)
506            expression.set("expressions", None)
507        elif expression.is_type(exp.DType.TEXT) and expression.expressions:
508            expression.set("this", exp.DType.VARCHAR)
509        elif expression.this in exp.DataType.TEMPORAL_TYPES:
510            expression.set("expressions", None)
511        elif expression.is_type("float"):
512            size_expression = expression.find(exp.DataTypeParam)
513            if size_expression:
514                size = int(size_expression.name)
515                expression.set("this", exp.DType.FLOAT if size <= 32 else exp.DType.DOUBLE)
516                expression.set("expressions", None)
517        return super().datatype_sql(expression)
518
519    def version_sql(self, expression: exp.Version) -> str:
520        sql = super().version_sql(expression)
521        return sql.replace("FOR ", "", 1)
522
523    def struct_sql(self, expression: exp.Struct) -> str:
524        values = []
525
526        for i, e in enumerate(expression.expressions):
527            if isinstance(e, exp.PropertyEQ):
528                self.unsupported("Hive does not support named structs.")
529                values.append(e.expression)
530            else:
531                values.append(e)
532
533        return self.func("STRUCT", *values)
534
535    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
536        return super().columndef_sql(
537            expression,
538            sep=(
539                ": "
540                if isinstance(expression.parent, exp.DataType)
541                and expression.parent.is_type("struct")
542                else sep
543            ),
544        )
545
546    def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
547        if expression.args.get("exists"):
548            self.unsupported("ALTER COLUMN IF EXISTS is not supported by this dialect")
549
550        this = self.sql(expression, "this")
551        new_name = self.sql(expression, "rename_to") or this
552        dtype = self.sql(expression, "dtype")
553        comment = (
554            f" COMMENT {self.sql(expression, 'comment')}" if self.sql(expression, "comment") else ""
555        )
556        default = self.sql(expression, "default")
557        visible = expression.args.get("visible")
558        allow_null = expression.args.get("allow_null")
559        drop = expression.args.get("drop")
560
561        if any([default, drop, visible]) or allow_null is not None:
562            self.unsupported("Unsupported CHANGE COLUMN syntax")
563
564        if not dtype:
565            self.unsupported("CHANGE COLUMN without a type is not supported")
566
567        return f"CHANGE COLUMN {this} {new_name} {dtype}{comment}"
568
569    def renamecolumn_sql(self, expression: exp.RenameColumn) -> str:
570        self.unsupported("Cannot rename columns without data type defined in Hive")
571        return ""
572
573    def alterset_sql(self, expression: exp.AlterSet) -> str:
574        exprs = self.expressions(expression, flat=True)
575        exprs = f" {exprs}" if exprs else ""
576        location = self.sql(expression, "location")
577        location = f" LOCATION {location}" if location else ""
578        file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
579        file_format = f" FILEFORMAT {file_format}" if file_format else ""
580        serde = self.sql(expression, "serde")
581        serde = f" SERDE {serde}" if serde else ""
582        tags = self.expressions(expression, key="tag", flat=True, sep="")
583        tags = f" TAGS {tags}" if tags else ""
584
585        return f"SET{serde}{exprs}{location}{file_format}{tags}"
586
587    def serdeproperties_sql(self, expression: exp.SerdeProperties) -> str:
588        prefix = "WITH " if expression.args.get("with_") else ""
589        exprs = self.expressions(expression, flat=True)
590
591        return f"{prefix}SERDEPROPERTIES ({exprs})"
592
593    def exists_sql(self, expression: exp.Exists) -> str:
594        if expression.expression:
595            return self.function_fallback_sql(expression)
596
597        return super().exists_sql(expression)
598
599    def timetostr_sql(self, expression: exp.TimeToStr) -> str:
600        this = expression.this
601        if isinstance(this, exp.TimeStrToTime):
602            this = this.this
603
604        return self.func("DATE_FORMAT", this, self.format_time(expression))
605
606    def usingproperty_sql(self, expression: exp.UsingProperty) -> str:
607        kind = expression.args.get("kind")
608        return f"USING {kind} {self.sql(expression, 'this')}"
609
610    def fileformatproperty_sql(self, expression: exp.FileFormatProperty) -> str:
611        if isinstance(expression.this, exp.InputOutputFormat):
612            this = self.sql(expression, "this")
613        else:
614            this = expression.name.upper()
615
616        return f"STORED AS {this}"