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