sqlglot.dialects.hive

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from sqlglot import exp, generator, parser, tokens, transforms
  6from sqlglot.dialects.dialect import (
  7    Dialect,
  8    approx_count_distinct_sql,
  9    create_with_partitions_sql,
 10    format_time_lambda,
 11    if_sql,
 12    is_parse_json,
 13    left_to_substring_sql,
 14    locate_to_strposition,
 15    max_or_greatest,
 16    min_or_least,
 17    no_ilike_sql,
 18    no_recursive_cte_sql,
 19    no_safe_divide_sql,
 20    no_trycast_sql,
 21    regexp_extract_sql,
 22    regexp_replace_sql,
 23    rename_func,
 24    right_to_substring_sql,
 25    strposition_to_locate_sql,
 26    struct_extract_sql,
 27    time_format,
 28    timestrtotime_sql,
 29    var_map_sql,
 30)
 31from sqlglot.helper import seq_get
 32from sqlglot.parser import parse_var_map
 33from sqlglot.tokens import TokenType
 34
 35# (FuncType, Multiplier)
 36DATE_DELTA_INTERVAL = {
 37    "YEAR": ("ADD_MONTHS", 12),
 38    "MONTH": ("ADD_MONTHS", 1),
 39    "QUARTER": ("ADD_MONTHS", 3),
 40    "WEEK": ("DATE_ADD", 7),
 41    "DAY": ("DATE_ADD", 1),
 42}
 43
 44TIME_DIFF_FACTOR = {
 45    "MILLISECOND": " * 1000",
 46    "SECOND": "",
 47    "MINUTE": " / 60",
 48    "HOUR": " / 3600",
 49}
 50
 51DIFF_MONTH_SWITCH = ("YEAR", "QUARTER", "MONTH")
 52
 53
 54def _add_date_sql(self: Hive.Generator, expression: exp.DateAdd | exp.DateSub) -> str:
 55    unit = expression.text("unit").upper()
 56    func, multiplier = DATE_DELTA_INTERVAL.get(unit, ("DATE_ADD", 1))
 57
 58    if isinstance(expression, exp.DateSub):
 59        multiplier *= -1
 60
 61    if expression.expression.is_number:
 62        modified_increment = exp.Literal.number(int(expression.text("expression")) * multiplier)
 63    else:
 64        modified_increment = expression.expression.copy()
 65        if multiplier != 1:
 66            modified_increment = exp.Mul(  # type: ignore
 67                this=modified_increment, expression=exp.Literal.number(multiplier)
 68            )
 69
 70    return self.func(func, expression.this, modified_increment)
 71
 72
 73def _date_diff_sql(self: Hive.Generator, expression: exp.DateDiff) -> str:
 74    unit = expression.text("unit").upper()
 75
 76    factor = TIME_DIFF_FACTOR.get(unit)
 77    if factor is not None:
 78        left = self.sql(expression, "this")
 79        right = self.sql(expression, "expression")
 80        sec_diff = f"UNIX_TIMESTAMP({left}) - UNIX_TIMESTAMP({right})"
 81        return f"({sec_diff}){factor}" if factor else sec_diff
 82
 83    sql_func = "MONTHS_BETWEEN" if unit in DIFF_MONTH_SWITCH else "DATEDIFF"
 84    _, multiplier = DATE_DELTA_INTERVAL.get(unit, ("", 1))
 85    multiplier_sql = f" / {multiplier}" if multiplier > 1 else ""
 86    diff_sql = f"{sql_func}({self.format_args(expression.this, expression.expression)})"
 87
 88    return f"{diff_sql}{multiplier_sql}"
 89
 90
 91def _json_format_sql(self: Hive.Generator, expression: exp.JSONFormat) -> str:
 92    this = expression.this
 93    if is_parse_json(this) and this.this.is_string:
 94        # Since FROM_JSON requires a nested type, we always wrap the json string with
 95        # an array to ensure that "naked" strings like "'a'" will be handled correctly
 96        wrapped_json = exp.Literal.string(f"[{this.this.name}]")
 97
 98        from_json = self.func("FROM_JSON", wrapped_json, self.func("SCHEMA_OF_JSON", wrapped_json))
 99        to_json = self.func("TO_JSON", from_json)
100
101        # This strips the [, ] delimiters of the dummy array printed by TO_JSON
102        return self.func("REGEXP_EXTRACT", to_json, "'^.(.*).$'", "1")
103
104    return self.func("TO_JSON", this, expression.args.get("options"))
105
106
107def _array_sort_sql(self: Hive.Generator, expression: exp.ArraySort) -> str:
108    if expression.expression:
109        self.unsupported("Hive SORT_ARRAY does not support a comparator")
110    return f"SORT_ARRAY({self.sql(expression, 'this')})"
111
112
113def _property_sql(self: Hive.Generator, expression: exp.Property) -> str:
114    return f"'{expression.name}'={self.sql(expression, 'value')}"
115
116
117def _str_to_unix_sql(self: Hive.Generator, expression: exp.StrToUnix) -> str:
118    return self.func("UNIX_TIMESTAMP", expression.this, time_format("hive")(self, expression))
119
120
121def _str_to_date_sql(self: Hive.Generator, expression: exp.StrToDate) -> str:
122    this = self.sql(expression, "this")
123    time_format = self.format_time(expression)
124    if time_format not in (Hive.TIME_FORMAT, Hive.DATE_FORMAT):
125        this = f"FROM_UNIXTIME(UNIX_TIMESTAMP({this}, {time_format}))"
126    return f"CAST({this} AS DATE)"
127
128
129def _str_to_time_sql(self: Hive.Generator, expression: exp.StrToTime) -> str:
130    this = self.sql(expression, "this")
131    time_format = self.format_time(expression)
132    if time_format not in (Hive.TIME_FORMAT, Hive.DATE_FORMAT):
133        this = f"FROM_UNIXTIME(UNIX_TIMESTAMP({this}, {time_format}))"
134    return f"CAST({this} AS TIMESTAMP)"
135
136
137def _time_to_str(self: Hive.Generator, expression: exp.TimeToStr) -> str:
138    this = self.sql(expression, "this")
139    time_format = self.format_time(expression)
140    return f"DATE_FORMAT({this}, {time_format})"
141
142
143def _to_date_sql(self: Hive.Generator, expression: exp.TsOrDsToDate) -> str:
144    this = self.sql(expression, "this")
145    time_format = self.format_time(expression)
146    if time_format and time_format not in (Hive.TIME_FORMAT, Hive.DATE_FORMAT):
147        return f"TO_DATE({this}, {time_format})"
148    return f"TO_DATE({this})"
149
150
151class Hive(Dialect):
152    ALIAS_POST_TABLESAMPLE = True
153    IDENTIFIERS_CAN_START_WITH_DIGIT = True
154    SUPPORTS_USER_DEFINED_TYPES = False
155
156    # https://spark.apache.org/docs/latest/sql-ref-identifier.html#description
157    RESOLVES_IDENTIFIERS_AS_UPPERCASE = None
158
159    TIME_MAPPING = {
160        "y": "%Y",
161        "Y": "%Y",
162        "YYYY": "%Y",
163        "yyyy": "%Y",
164        "YY": "%y",
165        "yy": "%y",
166        "MMMM": "%B",
167        "MMM": "%b",
168        "MM": "%m",
169        "M": "%-m",
170        "dd": "%d",
171        "d": "%-d",
172        "HH": "%H",
173        "H": "%-H",
174        "hh": "%I",
175        "h": "%-I",
176        "mm": "%M",
177        "m": "%-M",
178        "ss": "%S",
179        "s": "%-S",
180        "SSSSSS": "%f",
181        "a": "%p",
182        "DD": "%j",
183        "D": "%-j",
184        "E": "%a",
185        "EE": "%a",
186        "EEE": "%a",
187        "EEEE": "%A",
188    }
189
190    DATE_FORMAT = "'yyyy-MM-dd'"
191    DATEINT_FORMAT = "'yyyyMMdd'"
192    TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"
193
194    class Tokenizer(tokens.Tokenizer):
195        QUOTES = ["'", '"']
196        IDENTIFIERS = ["`"]
197        STRING_ESCAPES = ["\\"]
198        ENCODE = "utf-8"
199
200        KEYWORDS = {
201            **tokens.Tokenizer.KEYWORDS,
202            "ADD ARCHIVE": TokenType.COMMAND,
203            "ADD ARCHIVES": TokenType.COMMAND,
204            "ADD FILE": TokenType.COMMAND,
205            "ADD FILES": TokenType.COMMAND,
206            "ADD JAR": TokenType.COMMAND,
207            "ADD JARS": TokenType.COMMAND,
208            "MSCK REPAIR": TokenType.COMMAND,
209            "REFRESH": TokenType.COMMAND,
210            "WITH SERDEPROPERTIES": TokenType.SERDE_PROPERTIES,
211            "TIMESTAMP AS OF": TokenType.TIMESTAMP_SNAPSHOT,
212            "VERSION AS OF": TokenType.VERSION_SNAPSHOT,
213        }
214
215        NUMERIC_LITERALS = {
216            "L": "BIGINT",
217            "S": "SMALLINT",
218            "Y": "TINYINT",
219            "D": "DOUBLE",
220            "F": "FLOAT",
221            "BD": "DECIMAL",
222        }
223
224    class Parser(parser.Parser):
225        LOG_DEFAULTS_TO_LN = True
226        STRICT_CAST = False
227
228        FUNCTIONS = {
229            **parser.Parser.FUNCTIONS,
230            "BASE64": exp.ToBase64.from_arg_list,
231            "COLLECT_LIST": exp.ArrayAgg.from_arg_list,
232            "COLLECT_SET": exp.SetAgg.from_arg_list,
233            "DATE_ADD": lambda args: exp.TsOrDsAdd(
234                this=seq_get(args, 0), expression=seq_get(args, 1), unit=exp.Literal.string("DAY")
235            ),
236            "DATE_FORMAT": lambda args: format_time_lambda(exp.TimeToStr, "hive")(
237                [
238                    exp.TimeStrToTime(this=seq_get(args, 0)),
239                    seq_get(args, 1),
240                ]
241            ),
242            "DATE_SUB": lambda args: exp.TsOrDsAdd(
243                this=seq_get(args, 0),
244                expression=exp.Mul(this=seq_get(args, 1), expression=exp.Literal.number(-1)),
245                unit=exp.Literal.string("DAY"),
246            ),
247            "DATEDIFF": lambda args: exp.DateDiff(
248                this=exp.TsOrDsToDate(this=seq_get(args, 0)),
249                expression=exp.TsOrDsToDate(this=seq_get(args, 1)),
250            ),
251            "DAY": lambda args: exp.Day(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
252            "FROM_UNIXTIME": format_time_lambda(exp.UnixToStr, "hive", True),
253            "GET_JSON_OBJECT": exp.JSONExtractScalar.from_arg_list,
254            "LOCATE": locate_to_strposition,
255            "MAP": parse_var_map,
256            "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate.from_arg_list(args)),
257            "PERCENTILE": exp.Quantile.from_arg_list,
258            "PERCENTILE_APPROX": exp.ApproxQuantile.from_arg_list,
259            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
260                this=seq_get(args, 0), expression=seq_get(args, 1), group=seq_get(args, 2)
261            ),
262            "SIZE": exp.ArraySize.from_arg_list,
263            "SPLIT": exp.RegexpSplit.from_arg_list,
264            "STR_TO_MAP": lambda args: exp.StrToMap(
265                this=seq_get(args, 0),
266                pair_delim=seq_get(args, 1) or exp.Literal.string(","),
267                key_value_delim=seq_get(args, 2) or exp.Literal.string(":"),
268            ),
269            "TO_DATE": format_time_lambda(exp.TsOrDsToDate, "hive"),
270            "TO_JSON": exp.JSONFormat.from_arg_list,
271            "UNBASE64": exp.FromBase64.from_arg_list,
272            "UNIX_TIMESTAMP": format_time_lambda(exp.StrToUnix, "hive", True),
273            "YEAR": lambda args: exp.Year(this=exp.TsOrDsToDate.from_arg_list(args)),
274        }
275
276        NO_PAREN_FUNCTION_PARSERS = {
277            **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
278            "TRANSFORM": lambda self: self._parse_transform(),
279        }
280
281        PROPERTY_PARSERS = {
282            **parser.Parser.PROPERTY_PARSERS,
283            "WITH SERDEPROPERTIES": lambda self: exp.SerdeProperties(
284                expressions=self._parse_wrapped_csv(self._parse_property)
285            ),
286        }
287
288        def _parse_transform(self) -> t.Optional[exp.Transform | exp.QueryTransform]:
289            if not self._match(TokenType.L_PAREN, advance=False):
290                self._retreat(self._index - 1)
291                return None
292
293            args = self._parse_wrapped_csv(self._parse_lambda)
294            row_format_before = self._parse_row_format(match_row=True)
295
296            record_writer = None
297            if self._match_text_seq("RECORDWRITER"):
298                record_writer = self._parse_string()
299
300            if not self._match(TokenType.USING):
301                return exp.Transform.from_arg_list(args)
302
303            command_script = self._parse_string()
304
305            self._match(TokenType.ALIAS)
306            schema = self._parse_schema()
307
308            row_format_after = self._parse_row_format(match_row=True)
309            record_reader = None
310            if self._match_text_seq("RECORDREADER"):
311                record_reader = self._parse_string()
312
313            return self.expression(
314                exp.QueryTransform,
315                expressions=args,
316                command_script=command_script,
317                schema=schema,
318                row_format_before=row_format_before,
319                record_writer=record_writer,
320                row_format_after=row_format_after,
321                record_reader=record_reader,
322            )
323
324        def _parse_types(
325            self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
326        ) -> t.Optional[exp.Expression]:
327            """
328            Spark (and most likely Hive) treats casts to CHAR(length) and VARCHAR(length) as casts to
329            STRING in all contexts except for schema definitions. For example, this is in Spark v3.4.0:
330
331                spark-sql (default)> select cast(1234 as varchar(2));
332                23/06/06 15:51:18 WARN CharVarcharUtils: The Spark cast operator does not support
333                char/varchar type and simply treats them as string type. Please use string type
334                directly to avoid confusion. Otherwise, you can set spark.sql.legacy.charVarcharAsString
335                to true, so that Spark treat them as string type as same as Spark 3.0 and earlier
336
337                1234
338                Time taken: 4.265 seconds, Fetched 1 row(s)
339
340            This shows that Spark doesn't truncate the value into '12', which is inconsistent with
341            what other dialects (e.g. postgres) do, so we need to drop the length to transpile correctly.
342
343            Reference: https://spark.apache.org/docs/latest/sql-ref-datatypes.html
344            """
345            this = super()._parse_types(
346                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
347            )
348
349            if this and not schema:
350                return this.transform(
351                    lambda node: node.replace(exp.DataType.build("text"))
352                    if isinstance(node, exp.DataType) and node.is_type("char", "varchar")
353                    else node,
354                    copy=False,
355                )
356
357            return this
358
359        def _parse_partition_and_order(
360            self,
361        ) -> t.Tuple[t.List[exp.Expression], t.Optional[exp.Expression]]:
362            return (
363                self._parse_csv(self._parse_conjunction)
364                if self._match_set({TokenType.PARTITION_BY, TokenType.DISTRIBUTE_BY})
365                else [],
366                super()._parse_order(skip_order_token=self._match(TokenType.SORT_BY)),
367            )
368
369    class Generator(generator.Generator):
370        LIMIT_FETCH = "LIMIT"
371        TABLESAMPLE_WITH_METHOD = False
372        TABLESAMPLE_SIZE_IS_PERCENT = True
373        JOIN_HINTS = False
374        TABLE_HINTS = False
375        QUERY_HINTS = False
376        INDEX_ON = "ON TABLE"
377        EXTRACT_ALLOWS_QUOTES = False
378        NVL2_SUPPORTED = False
379
380        TYPE_MAPPING = {
381            **generator.Generator.TYPE_MAPPING,
382            exp.DataType.Type.BIT: "BOOLEAN",
383            exp.DataType.Type.DATETIME: "TIMESTAMP",
384            exp.DataType.Type.TEXT: "STRING",
385            exp.DataType.Type.TIME: "TIMESTAMP",
386            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
387            exp.DataType.Type.VARBINARY: "BINARY",
388        }
389
390        TRANSFORMS = {
391            **generator.Generator.TRANSFORMS,
392            exp.Group: transforms.preprocess([transforms.unalias_group]),
393            exp.Select: transforms.preprocess(
394                [
395                    transforms.eliminate_qualify,
396                    transforms.eliminate_distinct_on,
397                    transforms.unnest_to_explode,
398                ]
399            ),
400            exp.Property: _property_sql,
401            exp.AnyValue: rename_func("FIRST"),
402            exp.ApproxDistinct: approx_count_distinct_sql,
403            exp.ArrayConcat: rename_func("CONCAT"),
404            exp.ArrayJoin: lambda self, e: self.func("CONCAT_WS", e.expression, e.this),
405            exp.ArraySize: rename_func("SIZE"),
406            exp.ArraySort: _array_sort_sql,
407            exp.With: no_recursive_cte_sql,
408            exp.DateAdd: _add_date_sql,
409            exp.DateDiff: _date_diff_sql,
410            exp.DateStrToDate: rename_func("TO_DATE"),
411            exp.DateSub: _add_date_sql,
412            exp.DateToDi: lambda self, e: f"CAST(DATE_FORMAT({self.sql(e, 'this')}, {Hive.DATEINT_FORMAT}) AS INT)",
413            exp.DiToDate: lambda self, e: f"TO_DATE(CAST({self.sql(e, 'this')} AS STRING), {Hive.DATEINT_FORMAT})",
414            exp.FileFormatProperty: lambda self, e: f"STORED AS {self.sql(e, 'this') if isinstance(e.this, exp.InputOutputFormat) else e.name.upper()}",
415            exp.FromBase64: rename_func("UNBASE64"),
416            exp.If: if_sql(),
417            exp.ILike: no_ilike_sql,
418            exp.IsNan: rename_func("ISNAN"),
419            exp.JSONExtract: rename_func("GET_JSON_OBJECT"),
420            exp.JSONExtractScalar: rename_func("GET_JSON_OBJECT"),
421            exp.JSONFormat: _json_format_sql,
422            exp.Left: left_to_substring_sql,
423            exp.Map: var_map_sql,
424            exp.Max: max_or_greatest,
425            exp.MD5Digest: lambda self, e: self.func("UNHEX", self.func("MD5", e.this)),
426            exp.Min: min_or_least,
427            exp.MonthsBetween: lambda self, e: self.func("MONTHS_BETWEEN", e.this, e.expression),
428            exp.NotNullColumnConstraint: lambda self, e: ""
429            if e.args.get("allow_null")
430            else "NOT NULL",
431            exp.VarMap: var_map_sql,
432            exp.Create: create_with_partitions_sql,
433            exp.Quantile: rename_func("PERCENTILE"),
434            exp.ApproxQuantile: rename_func("PERCENTILE_APPROX"),
435            exp.RegexpExtract: regexp_extract_sql,
436            exp.RegexpReplace: regexp_replace_sql,
437            exp.RegexpLike: lambda self, e: self.binary(e, "RLIKE"),
438            exp.RegexpSplit: rename_func("SPLIT"),
439            exp.Right: right_to_substring_sql,
440            exp.SafeDivide: no_safe_divide_sql,
441            exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
442            exp.SetAgg: rename_func("COLLECT_SET"),
443            exp.Split: lambda self, e: f"SPLIT({self.sql(e, 'this')}, CONCAT('\\\\Q', {self.sql(e, 'expression')}))",
444            exp.StrPosition: strposition_to_locate_sql,
445            exp.StrToDate: _str_to_date_sql,
446            exp.StrToTime: _str_to_time_sql,
447            exp.StrToUnix: _str_to_unix_sql,
448            exp.StructExtract: struct_extract_sql,
449            exp.TimeStrToDate: rename_func("TO_DATE"),
450            exp.TimeStrToTime: timestrtotime_sql,
451            exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
452            exp.TimeToStr: _time_to_str,
453            exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"),
454            exp.ToBase64: rename_func("BASE64"),
455            exp.TsOrDiToDi: lambda self, e: f"CAST(SUBSTR(REPLACE(CAST({self.sql(e, 'this')} AS STRING), '-', ''), 1, 8) AS INT)",
456            exp.TsOrDsAdd: lambda self, e: f"DATE_ADD({self.sql(e, 'this')}, {self.sql(e, 'expression')})",
457            exp.TsOrDsToDate: _to_date_sql,
458            exp.TryCast: no_trycast_sql,
459            exp.UnixToStr: lambda self, e: self.func(
460                "FROM_UNIXTIME", e.this, time_format("hive")(self, e)
461            ),
462            exp.UnixToTime: rename_func("FROM_UNIXTIME"),
463            exp.UnixToTimeStr: rename_func("FROM_UNIXTIME"),
464            exp.PartitionedByProperty: lambda self, e: f"PARTITIONED BY {self.sql(e, 'this')}",
465            exp.SerdeProperties: lambda self, e: self.properties(e, prefix="WITH SERDEPROPERTIES"),
466            exp.NumberToStr: rename_func("FORMAT_NUMBER"),
467            exp.LastDateOfMonth: rename_func("LAST_DAY"),
468            exp.National: lambda self, e: self.national_sql(e, prefix=""),
469            exp.ClusteredColumnConstraint: lambda self, e: f"({self.expressions(e, 'this', indent=False)})",
470            exp.NonClusteredColumnConstraint: lambda self, e: f"({self.expressions(e, 'this', indent=False)})",
471            exp.NotForReplicationColumnConstraint: lambda self, e: "",
472            exp.OnProperty: lambda self, e: "",
473            exp.PrimaryKeyColumnConstraint: lambda self, e: "PRIMARY KEY",
474        }
475
476        PROPERTIES_LOCATION = {
477            **generator.Generator.PROPERTIES_LOCATION,
478            exp.FileFormatProperty: exp.Properties.Location.POST_SCHEMA,
479            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
480            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
481        }
482
483        def parameter_sql(self, expression: exp.Parameter) -> str:
484            this = self.sql(expression, "this")
485            parent = expression.parent
486
487            if isinstance(parent, exp.EQ) and isinstance(parent.parent, exp.SetItem):
488                # We need to produce SET key = value instead of SET ${key} = value
489                return this
490
491            return f"${{{this}}}"
492
493        def schema_sql(self, expression: exp.Schema) -> str:
494            expression = expression.copy()
495
496            for ordered in expression.find_all(exp.Ordered):
497                if ordered.args.get("desc") is False:
498                    ordered.set("desc", None)
499
500            return super().schema_sql(expression)
501
502        def constraint_sql(self, expression: exp.Constraint) -> str:
503            expression = expression.copy()
504
505            for prop in list(expression.find_all(exp.Properties)):
506                prop.pop()
507
508            this = self.sql(expression, "this")
509            expressions = self.expressions(expression, sep=" ", flat=True)
510            return f"CONSTRAINT {this} {expressions}"
511
512        def rowformatserdeproperty_sql(self, expression: exp.RowFormatSerdeProperty) -> str:
513            serde_props = self.sql(expression, "serde_properties")
514            serde_props = f" {serde_props}" if serde_props else ""
515            return f"ROW FORMAT SERDE {self.sql(expression, 'this')}{serde_props}"
516
517        def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
518            return self.func(
519                "COLLECT_LIST",
520                expression.this.this if isinstance(expression.this, exp.Order) else expression.this,
521            )
522
523        def with_properties(self, properties: exp.Properties) -> str:
524            return self.properties(properties, prefix=self.seg("TBLPROPERTIES"))
525
526        def datatype_sql(self, expression: exp.DataType) -> str:
527            if (
528                expression.this in (exp.DataType.Type.VARCHAR, exp.DataType.Type.NVARCHAR)
529                and not expression.expressions
530            ):
531                expression = exp.DataType.build("text")
532            elif expression.this in exp.DataType.TEMPORAL_TYPES:
533                expression = exp.DataType.build(expression.this)
534            elif expression.is_type("float"):
535                size_expression = expression.find(exp.DataTypeParam)
536                if size_expression:
537                    size = int(size_expression.name)
538                    expression = (
539                        exp.DataType.build("float") if size <= 32 else exp.DataType.build("double")
540                    )
541
542            return super().datatype_sql(expression)
543
544        def version_sql(self, expression: exp.Version) -> str:
545            sql = super().version_sql(expression)
546            return sql.replace("FOR ", "", 1)