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    is_parse_json,
 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    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
 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# (FuncType, Multiplier)
 49DATE_DELTA_INTERVAL = {
 50    "YEAR": ("ADD_MONTHS", 12),
 51    "MONTH": ("ADD_MONTHS", 1),
 52    "QUARTER": ("ADD_MONTHS", 3),
 53    "WEEK": ("DATE_ADD", 7),
 54    "DAY": ("DATE_ADD", 1),
 55}
 56
 57TIME_DIFF_FACTOR = {
 58    "MILLISECOND": " * 1000",
 59    "SECOND": "",
 60    "MINUTE": " / 60",
 61    "HOUR": " / 3600",
 62}
 63
 64DIFF_MONTH_SWITCH = ("YEAR", "QUARTER", "MONTH")
 65
 66HIVE_TS_OR_DS_EXPRESSIONS: tuple[type[exp.Expr], ...] = (
 67    exp.DateDiff,
 68    exp.Day,
 69    exp.Month,
 70    exp.Year,
 71)
 72
 73
 74def _add_date_sql(self: HiveGenerator, expression: DATE_ADD_OR_SUB) -> str:
 75    if isinstance(expression, exp.TsOrDsAdd) and not expression.unit:
 76        return self.func("DATE_ADD", expression.this, expression.expression)
 77
 78    unit = expression.text("unit").upper()
 79    func, multiplier = DATE_DELTA_INTERVAL.get(unit, ("DATE_ADD", 1))
 80
 81    if isinstance(expression, exp.DateSub):
 82        multiplier *= -1
 83
 84    increment = expression.expression
 85    if isinstance(increment, exp.Literal):
 86        value = increment.to_py() if increment.is_number else int(increment.name)
 87        increment = exp.Literal.number(value * multiplier)
 88    elif multiplier != 1:
 89        increment *= exp.Literal.number(multiplier)
 90
 91    return self.func(func, expression.this, increment)
 92
 93
 94def _date_diff_sql(self: HiveGenerator, expression: exp.DateDiff | exp.TsOrDsDiff) -> str:
 95    unit = expression.text("unit").upper()
 96
 97    factor = TIME_DIFF_FACTOR.get(unit)
 98    if factor is not None:
 99        left = self.sql(expression, "this")
100        right = self.sql(expression, "expression")
101        sec_diff = f"UNIX_TIMESTAMP({left}) - UNIX_TIMESTAMP({right})"
102        return f"({sec_diff}){factor}" if factor else sec_diff
103
104    months_between = unit in DIFF_MONTH_SWITCH
105    sql_func = "MONTHS_BETWEEN" if months_between else "DATEDIFF"
106    _, multiplier = DATE_DELTA_INTERVAL.get(unit, ("", 1))
107    multiplier_sql = f" / {multiplier}" if multiplier > 1 else ""
108    diff_sql = f"{sql_func}({self.format_args(expression.this, expression.expression)})"
109
110    if months_between or multiplier_sql:
111        # MONTHS_BETWEEN returns a float, so we need to truncate the fractional part.
112        # For the same reason, we want to truncate if there's a divisor present.
113        diff_sql = f"CAST({diff_sql}{multiplier_sql} AS INT)"
114
115    return diff_sql
116
117
118def _json_format_sql(self: HiveGenerator, expression: exp.JSONFormat) -> str:
119    this = expression.this
120
121    if is_parse_json(this):
122        if this.this.is_string:
123            # Since FROM_JSON requires a nested type, we always wrap the json string with
124            # an array to ensure that "naked" strings like "'a'" will be handled correctly
125            wrapped_json = exp.Literal.string(f"[{this.this.name}]")
126
127            from_json = self.func(
128                "FROM_JSON", wrapped_json, self.func("SCHEMA_OF_JSON", wrapped_json)
129            )
130            to_json = self.func("TO_JSON", from_json)
131
132            # This strips the [, ] delimiters of the dummy array printed by TO_JSON
133            return self.func("REGEXP_EXTRACT", to_json, "'^.(.*).$'", "1")
134        return self.sql(this)
135
136    return self.func("TO_JSON", this, expression.args.get("options"))
137
138
139@generator.unsupported_args(("expression", "Hive's SORT_ARRAY does not support a comparator."))
140def _array_sort_sql(self: HiveGenerator, expression: exp.ArraySort) -> str:
141    return self.func("SORT_ARRAY", expression.this)
142
143
144def _str_to_unix_sql(self: HiveGenerator, expression: exp.StrToUnix) -> str:
145    return self.func("UNIX_TIMESTAMP", expression.this, time_format("hive")(self, expression))
146
147
148def _unix_to_time_sql(self: HiveGenerator, expression: exp.UnixToTime) -> str:
149    timestamp = self.sql(expression, "this")
150    scale = expression.args.get("scale")
151    if scale in (None, exp.UnixToTime.SECONDS):
152        return rename_func("FROM_UNIXTIME")(self, expression)
153
154    return f"FROM_UNIXTIME({timestamp} / POW(10, {scale}))"
155
156
157def _str_to_date_sql(self: HiveGenerator, expression: exp.StrToDate) -> str:
158    this = self.sql(expression, "this")
159    time_format = self.format_time(expression)
160    if time_format not in (HIVE_TIME_FORMAT, HIVE_DATE_FORMAT):
161        this = f"FROM_UNIXTIME(UNIX_TIMESTAMP({this}, {time_format}))"
162    return f"CAST({this} AS DATE)"
163
164
165def _str_to_time_sql(self: HiveGenerator, expression: exp.StrToTime) -> str:
166    this = self.sql(expression, "this")
167    time_format = self.format_time(expression)
168    if time_format not in (HIVE_TIME_FORMAT, HIVE_DATE_FORMAT):
169        this = f"FROM_UNIXTIME(UNIX_TIMESTAMP({this}, {time_format}))"
170    return f"CAST({this} AS TIMESTAMP)"
171
172
173def _to_date_sql(self: HiveGenerator, expression: exp.TsOrDsToDate) -> str:
174    time_format = self.format_time(expression)
175    if time_format and time_format not in (HIVE_TIME_FORMAT, HIVE_DATE_FORMAT):
176        return self.func("TO_DATE", expression.this, time_format)
177
178    if isinstance(expression.parent, self.TS_OR_DS_EXPRESSIONS):
179        return self.sql(expression, "this")
180
181    return self.func("TO_DATE", expression.this)
182
183
184class HiveGenerator(generator.Generator):
185    SELECT_KINDS: tuple[str, ...] = ()
186    TRY_SUPPORTED = False
187    SUPPORTS_UESCAPE = False
188    SUPPORTS_DECODE_CASE = False
189    LIMIT_FETCH = "LIMIT"
190    TABLESAMPLE_WITH_METHOD = False
191    JOIN_HINTS = False
192    TABLE_HINTS = False
193    QUERY_HINTS = False
194    INDEX_ON = "ON TABLE"
195    EXTRACT_ALLOWS_QUOTES = False
196    NVL2_SUPPORTED = False
197    LAST_DAY_SUPPORTS_DATE_PART = False
198    JSON_PATH_SINGLE_QUOTE_ESCAPE = True
199    SAFE_JSON_PATH_KEY_RE = re.compile(r"^[_\-a-zA-Z][\-\w]*$")
200    SUPPORTS_TO_NUMBER = False
201    WITH_PROPERTIES_PREFIX = "TBLPROPERTIES"
202    PARSE_JSON_NAME: str | None = None
203    PAD_FILL_PATTERN_IS_REQUIRED = True
204    SUPPORTS_MEDIAN = False
205    ARRAY_SIZE_NAME = "SIZE"
206    ALTER_SET_TYPE = ""
207
208    EXPRESSIONS_WITHOUT_NESTED_CTES = {
209        exp.Insert,
210        exp.Select,
211        exp.Subquery,
212        exp.SetOperation,
213    }
214
215    SUPPORTED_JSON_PATH_PARTS = {
216        exp.JSONPathKey,
217        exp.JSONPathRoot,
218        exp.JSONPathSubscript,
219        exp.JSONPathWildcard,
220    }
221
222    TYPE_MAPPING = {
223        **generator.Generator.TYPE_MAPPING,
224        exp.DType.BIT: "BOOLEAN",
225        exp.DType.BLOB: "BINARY",
226        exp.DType.DATETIME: "TIMESTAMP",
227        exp.DType.ROWVERSION: "BINARY",
228        exp.DType.TEXT: "STRING",
229        exp.DType.TIME: "TIMESTAMP",
230        exp.DType.TIMESTAMPNTZ: "TIMESTAMP",
231        exp.DType.TIMESTAMPTZ: "TIMESTAMP",
232        exp.DType.UTINYINT: "SMALLINT",
233        exp.DType.VARBINARY: "BINARY",
234    }
235
236    TRANSFORMS = {
237        **generator.Generator.TRANSFORMS,
238        exp.Property: property_sql,
239        exp.AnyValue: rename_func("FIRST"),
240        exp.ApproxDistinct: approx_count_distinct_sql,
241        exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
242        exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
243        exp.Array: transforms.preprocess([transforms.inherit_struct_field_names]),
244        exp.ArrayConcat: rename_func("CONCAT"),
245        exp.ArrayToString: lambda self, e: self.func("CONCAT_WS", e.expression, e.this),
246        exp.ArraySort: _array_sort_sql,
247        exp.With: no_recursive_cte_sql,
248        exp.DateAdd: _add_date_sql,
249        exp.DateDiff: _date_diff_sql,
250        exp.DateStrToDate: datestrtodate_sql,
251        exp.DateSub: _add_date_sql,
252        exp.DateToDi: lambda self, e: (
253            f"CAST(DATE_FORMAT({self.sql(e, 'this')}, {HIVE_DATEINT_FORMAT}) AS INT)"
254        ),
255        exp.DiToDate: lambda self, e: (
256            f"TO_DATE(CAST({self.sql(e, 'this')} AS STRING), {HIVE_DATEINT_FORMAT})"
257        ),
258        exp.StorageHandlerProperty: lambda self, e: f"STORED BY {self.sql(e, 'this')}",
259        exp.FromBase64: rename_func("UNBASE64"),
260        exp.GenerateSeries: sequence_sql,
261        exp.GenerateDateArray: sequence_sql,
262        exp.If: if_sql(),
263        exp.ILike: no_ilike_sql,
264        exp.IntDiv: lambda self, e: self.binary(e, "DIV"),
265        exp.IsNan: rename_func("ISNAN"),
266        exp.JSONExtract: lambda self, e: self.func("GET_JSON_OBJECT", e.this, e.expression),
267        exp.JSONExtractScalar: lambda self, e: self.func("GET_JSON_OBJECT", e.this, e.expression),
268        exp.JSONFormat: _json_format_sql,
269        exp.Left: left_to_substring_sql,
270        exp.Map: var_map_sql,
271        exp.Max: max_or_greatest,
272        exp.MD5Digest: lambda self, e: self.func("UNHEX", self.func("MD5", e.this)),
273        exp.Min: min_or_least,
274        exp.MonthsBetween: lambda self, e: self.func("MONTHS_BETWEEN", e.this, e.expression),
275        exp.NotNullColumnConstraint: lambda _, e: "" if e.args.get("allow_null") else "NOT NULL",
276        exp.VarMap: var_map_sql,
277        exp.Create: preprocess(
278            [
279                remove_unique_constraints,
280                ctas_with_tmp_tables_to_create_tmp_view,
281                move_schema_columns_to_partitioned_by,
282            ]
283        ),
284        exp.Quantile: rename_func("PERCENTILE"),
285        exp.ApproxQuantile: rename_func("PERCENTILE_APPROX"),
286        exp.RegexpExtract: regexp_extract_sql,
287        exp.RegexpExtractAll: regexp_extract_sql,
288        exp.RegexpReplace: regexp_replace_sql,
289        exp.RegexpLike: lambda self, e: self.binary(e, "RLIKE"),
290        exp.RegexpSplit: rename_func("SPLIT"),
291        exp.Right: right_to_substring_sql,
292        exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
293        exp.ArrayUniqueAgg: rename_func("COLLECT_SET"),
294        exp.Split: lambda self, e: self.func(
295            "SPLIT", e.this, self.func("CONCAT", "'\\\\Q'", e.expression, "'\\\\E'")
296        ),
297        exp.Select: transforms.preprocess(
298            [
299                transforms.eliminate_qualify,
300                transforms.eliminate_distinct_on,
301                partial(transforms.unnest_to_explode, unnest_using_arrays_zip=False),
302                transforms.any_to_exists,
303            ]
304        ),
305        exp.StrPosition: lambda self, e: strposition_sql(
306            self, e, func_name="LOCATE", supports_position=True
307        ),
308        exp.StrToDate: _str_to_date_sql,
309        exp.StrToTime: _str_to_time_sql,
310        exp.StrToUnix: _str_to_unix_sql,
311        exp.StructExtract: struct_extract_sql,
312        exp.StarMap: rename_func("MAP"),
313        exp.Table: transforms.preprocess([transforms.unnest_generate_series]),
314        exp.TimeStrToDate: rename_func("TO_DATE"),
315        exp.TimeStrToTime: timestrtotime_sql,
316        exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
317        exp.TimestampTrunc: lambda self, e: self.func("TRUNC", e.this, unit_to_str(e)),
318        exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"),
319        exp.ToBase64: rename_func("BASE64"),
320        exp.TsOrDiToDi: lambda self, e: (
321            f"CAST(SUBSTR(REPLACE(CAST({self.sql(e, 'this')} AS STRING), '-', ''), 1, 8) AS INT)"
322        ),
323        exp.TsOrDsAdd: _add_date_sql,
324        exp.TsOrDsDiff: _date_diff_sql,
325        exp.TsOrDsToDate: _to_date_sql,
326        exp.TryCast: no_trycast_sql,
327        exp.Trim: trim_sql,
328        exp.Unicode: rename_func("ASCII"),
329        exp.UnixToStr: lambda self, e: self.func(
330            "FROM_UNIXTIME", e.this, time_format("hive")(self, e)
331        ),
332        exp.UnixToTime: _unix_to_time_sql,
333        exp.UnixToTimeStr: rename_func("FROM_UNIXTIME"),
334        exp.Unnest: rename_func("EXPLODE"),
335        exp.PartitionedByProperty: lambda self, e: f"PARTITIONED BY {self.sql(e, 'this')}",
336        exp.NumberToStr: rename_func("FORMAT_NUMBER"),
337        exp.National: lambda self, e: self.national_sql(e, prefix=""),
338        exp.ClusteredColumnConstraint: lambda self, e: (
339            f"({self.expressions(e, 'this', indent=False)})"
340        ),
341        exp.NonClusteredColumnConstraint: lambda self, e: (
342            f"({self.expressions(e, 'this', indent=False)})"
343        ),
344        exp.NotForReplicationColumnConstraint: lambda *_: "",
345        exp.OnProperty: lambda *_: "",
346        exp.PartitionedByBucket: lambda self, e: self.func("BUCKET", e.expression, e.this),
347        exp.PartitionByTruncate: lambda self, e: self.func("TRUNCATE", e.expression, e.this),
348        exp.PrimaryKeyColumnConstraint: lambda *_: "PRIMARY KEY",
349        exp.WeekOfYear: rename_func("WEEKOFYEAR"),
350        exp.DayOfMonth: rename_func("DAYOFMONTH"),
351        exp.DayOfWeek: rename_func("DAYOFWEEK"),
352        exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
353            rename_func("LEVENSHTEIN")
354        ),
355    }
356
357    PROPERTIES_LOCATION = {
358        **generator.Generator.PROPERTIES_LOCATION,
359        exp.FileFormatProperty: exp.Properties.Location.POST_SCHEMA,
360        exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
361        exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
362        exp.WithDataProperty: exp.Properties.Location.UNSUPPORTED,
363    }
364
365    TS_OR_DS_EXPRESSIONS = HIVE_TS_OR_DS_EXPRESSIONS
366
367    IGNORE_NULLS_FUNCS = (exp.First, exp.Last, exp.FirstValue, exp.LastValue)
368
369    def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
370        this = expression.this
371        if isinstance(this, self.IGNORE_NULLS_FUNCS):
372            return self.func(this.sql_name(), this.this, exp.true())
373
374        return super().ignorenulls_sql(expression)
375
376    def unnest_sql(self, expression: exp.Unnest) -> str:
377        return rename_func("EXPLODE")(self, expression)
378
379    def _jsonpathkey_sql(self, expression: exp.JSONPathKey) -> str:
380        if isinstance(expression.this, exp.JSONPathWildcard):
381            self.unsupported("Unsupported wildcard in JSONPathKey expression")
382            return ""
383
384        return super()._jsonpathkey_sql(expression)
385
386    def parameter_sql(self, expression: exp.Parameter) -> str:
387        this = self.sql(expression, "this")
388        expression_sql = self.sql(expression, "expression")
389
390        parent = expression.parent
391        this = f"{this}:{expression_sql}" if expression_sql else this
392
393        if isinstance(parent, exp.EQ) and isinstance(parent.parent, exp.SetItem):
394            # We need to produce SET key = value instead of SET ${key} = value
395            return this
396
397        return f"${{{this}}}"
398
399    def schema_sql(self, expression: exp.Schema) -> str:
400        for ordered in expression.find_all(exp.Ordered):
401            if ordered.args.get("desc") is False:
402                ordered.set("desc", None)
403
404        return super().schema_sql(expression)
405
406    def constraint_sql(self, expression: exp.Constraint) -> str:
407        for prop in list(expression.find_all(exp.Properties)):
408            prop.pop()
409
410        this = self.sql(expression, "this")
411        expressions = self.expressions(expression, sep=" ", flat=True)
412        return f"CONSTRAINT {this} {expressions}"
413
414    def rowformatserdeproperty_sql(self, expression: exp.RowFormatSerdeProperty) -> str:
415        serde_props = self.sql(expression, "serde_properties")
416        serde_props = f" {serde_props}" if serde_props else ""
417        return f"ROW FORMAT SERDE {self.sql(expression, 'this')}{serde_props}"
418
419    def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
420        return self.func(
421            "COLLECT_LIST",
422            expression.this.this if isinstance(expression.this, exp.Order) else expression.this,
423        )
424
425    # Hive/Spark lack native numeric TRUNC. CAST to BIGINT truncates toward zero (not rounds).
426    # Potential enhancement: a TRUNC_TEMPLATE using FLOOR/CEIL with scale (Spark 3.3+)
427    # could preserve decimals: CASE WHEN x >= 0 THEN FLOOR(x, d) ELSE CEIL(x, d) END
428    @unsupported_args("decimals")
429    def trunc_sql(self, expression: exp.Trunc) -> str:
430        return self.sql(exp.cast(expression.this, exp.DType.BIGINT))
431
432    def datatype_sql(self, expression: exp.DataType) -> str:
433        if expression.this in self.PARAMETERIZABLE_TEXT_TYPES and (
434            not expression.expressions or expression.expressions[0].name == "MAX"
435        ):
436            expression = exp.DType.TEXT.into_expr()
437        elif expression.is_type(exp.DType.TEXT) and expression.expressions:
438            expression.set("this", exp.DType.VARCHAR)
439        elif expression.this in exp.DataType.TEMPORAL_TYPES:
440            expression = exp.DataType.build(expression.this)
441        elif expression.is_type("float"):
442            size_expression = expression.find(exp.DataTypeParam)
443            if size_expression:
444                size = int(size_expression.name)
445                builder = exp.DType.FLOAT if size <= 32 else exp.DType.DOUBLE
446                expression = builder.into_expr()
447        return super().datatype_sql(expression)
448
449    def version_sql(self, expression: exp.Version) -> str:
450        sql = super().version_sql(expression)
451        return sql.replace("FOR ", "", 1)
452
453    def struct_sql(self, expression: exp.Struct) -> str:
454        values = []
455
456        for i, e in enumerate(expression.expressions):
457            if isinstance(e, exp.PropertyEQ):
458                self.unsupported("Hive does not support named structs.")
459                values.append(e.expression)
460            else:
461                values.append(e)
462
463        return self.func("STRUCT", *values)
464
465    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
466        return super().columndef_sql(
467            expression,
468            sep=(
469                ": "
470                if isinstance(expression.parent, exp.DataType)
471                and expression.parent.is_type("struct")
472                else sep
473            ),
474        )
475
476    def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
477        this = self.sql(expression, "this")
478        new_name = self.sql(expression, "rename_to") or this
479        dtype = self.sql(expression, "dtype")
480        comment = (
481            f" COMMENT {self.sql(expression, 'comment')}" if self.sql(expression, "comment") else ""
482        )
483        default = self.sql(expression, "default")
484        visible = expression.args.get("visible")
485        allow_null = expression.args.get("allow_null")
486        drop = expression.args.get("drop")
487
488        if any([default, drop, visible, allow_null, drop]):
489            self.unsupported("Unsupported CHANGE COLUMN syntax")
490
491        if not dtype:
492            self.unsupported("CHANGE COLUMN without a type is not supported")
493
494        return f"CHANGE COLUMN {this} {new_name} {dtype}{comment}"
495
496    def renamecolumn_sql(self, expression: exp.RenameColumn) -> str:
497        self.unsupported("Cannot rename columns without data type defined in Hive")
498        return ""
499
500    def alterset_sql(self, expression: exp.AlterSet) -> str:
501        exprs = self.expressions(expression, flat=True)
502        exprs = f" {exprs}" if exprs else ""
503        location = self.sql(expression, "location")
504        location = f" LOCATION {location}" if location else ""
505        file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
506        file_format = f" FILEFORMAT {file_format}" if file_format else ""
507        serde = self.sql(expression, "serde")
508        serde = f" SERDE {serde}" if serde else ""
509        tags = self.expressions(expression, key="tag", flat=True, sep="")
510        tags = f" TAGS {tags}" if tags else ""
511
512        return f"SET{serde}{exprs}{location}{file_format}{tags}"
513
514    def serdeproperties_sql(self, expression: exp.SerdeProperties) -> str:
515        prefix = "WITH " if expression.args.get("with_") else ""
516        exprs = self.expressions(expression, flat=True)
517
518        return f"{prefix}SERDEPROPERTIES ({exprs})"
519
520    def exists_sql(self, expression: exp.Exists) -> str:
521        if expression.expression:
522            return self.function_fallback_sql(expression)
523
524        return super().exists_sql(expression)
525
526    def timetostr_sql(self, expression: exp.TimeToStr) -> str:
527        this = expression.this
528        if isinstance(this, exp.TimeStrToTime):
529            this = this.this
530
531        return self.func("DATE_FORMAT", this, self.format_time(expression))
532
533    def usingproperty_sql(self, expression: exp.UsingProperty) -> str:
534        kind = expression.args.get("kind")
535        return f"USING {kind} {self.sql(expression, 'this')}"
536
537    def fileformatproperty_sql(self, expression: exp.FileFormatProperty) -> str:
538        if isinstance(expression.this, exp.InputOutputFormat):
539            this = self.sql(expression, "this")
540        else:
541            this = expression.name.upper()
542
543        return f"STORED AS {this}"