sqlglot.dialects.presto

  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    NormalizationStrategy,
  9    binary_from_function,
 10    bool_xor_sql,
 11    date_trunc_to_time,
 12    datestrtodate_sql,
 13    encode_decode_sql,
 14    build_formatted_time,
 15    if_sql,
 16    left_to_substring_sql,
 17    no_ilike_sql,
 18    no_pivot_sql,
 19    no_safe_divide_sql,
 20    no_timestamp_sql,
 21    regexp_extract_sql,
 22    rename_func,
 23    right_to_substring_sql,
 24    struct_extract_sql,
 25    timestamptrunc_sql,
 26    timestrtotime_sql,
 27    ts_or_ds_add_cast,
 28)
 29from sqlglot.dialects.hive import Hive
 30from sqlglot.dialects.mysql import MySQL
 31from sqlglot.helper import apply_index_offset, seq_get
 32from sqlglot.tokens import TokenType
 33
 34
 35def _explode_to_unnest_sql(self: Presto.Generator, expression: exp.Lateral) -> str:
 36    if isinstance(expression.this, exp.Explode):
 37        return self.sql(
 38            exp.Join(
 39                this=exp.Unnest(
 40                    expressions=[expression.this.this],
 41                    alias=expression.args.get("alias"),
 42                    offset=isinstance(expression.this, exp.Posexplode),
 43                ),
 44                kind="cross",
 45            )
 46        )
 47    return self.lateral_sql(expression)
 48
 49
 50def _initcap_sql(self: Presto.Generator, expression: exp.Initcap) -> str:
 51    regex = r"(\w)(\w*)"
 52    return f"REGEXP_REPLACE({self.sql(expression, 'this')}, '{regex}', x -> UPPER(x[1]) || LOWER(x[2]))"
 53
 54
 55def _no_sort_array(self: Presto.Generator, expression: exp.SortArray) -> str:
 56    if expression.args.get("asc") == exp.false():
 57        comparator = "(a, b) -> CASE WHEN a < b THEN 1 WHEN a > b THEN -1 ELSE 0 END"
 58    else:
 59        comparator = None
 60    return self.func("ARRAY_SORT", expression.this, comparator)
 61
 62
 63def _schema_sql(self: Presto.Generator, expression: exp.Schema) -> str:
 64    if isinstance(expression.parent, exp.Property):
 65        columns = ", ".join(f"'{c.name}'" for c in expression.expressions)
 66        return f"ARRAY[{columns}]"
 67
 68    if expression.parent:
 69        for schema in expression.parent.find_all(exp.Schema):
 70            column_defs = schema.find_all(exp.ColumnDef)
 71            if column_defs and isinstance(schema.parent, exp.Property):
 72                expression.expressions.extend(column_defs)
 73
 74    return self.schema_sql(expression)
 75
 76
 77def _quantile_sql(self: Presto.Generator, expression: exp.Quantile) -> str:
 78    self.unsupported("Presto does not support exact quantiles")
 79    return self.func("APPROX_PERCENTILE", expression.this, expression.args.get("quantile"))
 80
 81
 82def _str_to_time_sql(
 83    self: Presto.Generator, expression: exp.StrToDate | exp.StrToTime | exp.TsOrDsToDate
 84) -> str:
 85    return self.func("DATE_PARSE", expression.this, self.format_time(expression))
 86
 87
 88def _ts_or_ds_to_date_sql(self: Presto.Generator, expression: exp.TsOrDsToDate) -> str:
 89    time_format = self.format_time(expression)
 90    if time_format and time_format not in (Presto.TIME_FORMAT, Presto.DATE_FORMAT):
 91        return self.sql(exp.cast(_str_to_time_sql(self, expression), "DATE"))
 92    return self.sql(exp.cast(exp.cast(expression.this, "TIMESTAMP"), "DATE"))
 93
 94
 95def _ts_or_ds_add_sql(self: Presto.Generator, expression: exp.TsOrDsAdd) -> str:
 96    expression = ts_or_ds_add_cast(expression)
 97    unit = exp.Literal.string(expression.text("unit") or "DAY")
 98    return self.func("DATE_ADD", unit, expression.expression, expression.this)
 99
100
101def _ts_or_ds_diff_sql(self: Presto.Generator, expression: exp.TsOrDsDiff) -> str:
102    this = exp.cast(expression.this, "TIMESTAMP")
103    expr = exp.cast(expression.expression, "TIMESTAMP")
104    unit = exp.Literal.string(expression.text("unit") or "DAY")
105    return self.func("DATE_DIFF", unit, expr, this)
106
107
108def _build_approx_percentile(args: t.List) -> exp.Expression:
109    if len(args) == 4:
110        return exp.ApproxQuantile(
111            this=seq_get(args, 0),
112            weight=seq_get(args, 1),
113            quantile=seq_get(args, 2),
114            accuracy=seq_get(args, 3),
115        )
116    if len(args) == 3:
117        return exp.ApproxQuantile(
118            this=seq_get(args, 0), quantile=seq_get(args, 1), accuracy=seq_get(args, 2)
119        )
120    return exp.ApproxQuantile.from_arg_list(args)
121
122
123def _build_from_unixtime(args: t.List) -> exp.Expression:
124    if len(args) == 3:
125        return exp.UnixToTime(
126            this=seq_get(args, 0),
127            hours=seq_get(args, 1),
128            minutes=seq_get(args, 2),
129        )
130    if len(args) == 2:
131        return exp.UnixToTime(this=seq_get(args, 0), zone=seq_get(args, 1))
132
133    return exp.UnixToTime.from_arg_list(args)
134
135
136def _unnest_sequence(expression: exp.Expression) -> exp.Expression:
137    if isinstance(expression, exp.Table):
138        if isinstance(expression.this, exp.GenerateSeries):
139            unnest = exp.Unnest(expressions=[expression.this])
140
141            if expression.alias:
142                return exp.alias_(unnest, alias="_u", table=[expression.alias], copy=False)
143            return unnest
144    return expression
145
146
147def _first_last_sql(self: Presto.Generator, expression: exp.Func) -> str:
148    """
149    Trino doesn't support FIRST / LAST as functions, but they're valid in the context
150    of MATCH_RECOGNIZE, so we need to preserve them in that case. In all other cases
151    they're converted into an ARBITRARY call.
152
153    Reference: https://trino.io/docs/current/sql/match-recognize.html#logical-navigation-functions
154    """
155    if isinstance(expression.find_ancestor(exp.MatchRecognize, exp.Select), exp.MatchRecognize):
156        return self.function_fallback_sql(expression)
157
158    return rename_func("ARBITRARY")(self, expression)
159
160
161def _unix_to_time_sql(self: Presto.Generator, expression: exp.UnixToTime) -> str:
162    scale = expression.args.get("scale")
163    timestamp = self.sql(expression, "this")
164    if scale in (None, exp.UnixToTime.SECONDS):
165        return rename_func("FROM_UNIXTIME")(self, expression)
166
167    return f"FROM_UNIXTIME(CAST({timestamp} AS DOUBLE) / POW(10, {scale}))"
168
169
170def _to_int(expression: exp.Expression) -> exp.Expression:
171    if not expression.type:
172        from sqlglot.optimizer.annotate_types import annotate_types
173
174        annotate_types(expression)
175    if expression.type and expression.type.this not in exp.DataType.INTEGER_TYPES:
176        return exp.cast(expression, to=exp.DataType.Type.BIGINT)
177    return expression
178
179
180def _build_to_char(args: t.List) -> exp.TimeToStr:
181    fmt = seq_get(args, 1)
182    if isinstance(fmt, exp.Literal):
183        # We uppercase this to match Teradata's format mapping keys
184        fmt.set("this", fmt.this.upper())
185
186    # We use "teradata" on purpose here, because the time formats are different in Presto.
187    # See https://prestodb.io/docs/current/functions/teradata.html?highlight=to_char#to_char
188    return build_formatted_time(exp.TimeToStr, "teradata")(args)
189
190
191class Presto(Dialect):
192    INDEX_OFFSET = 1
193    NULL_ORDERING = "nulls_are_last"
194    TIME_FORMAT = MySQL.TIME_FORMAT
195    TIME_MAPPING = MySQL.TIME_MAPPING
196    STRICT_STRING_CONCAT = True
197    SUPPORTS_SEMI_ANTI_JOIN = False
198    TYPED_DIVISION = True
199    TABLESAMPLE_SIZE_IS_PERCENT = True
200    LOG_BASE_FIRST: t.Optional[bool] = None
201
202    # https://github.com/trinodb/trino/issues/17
203    # https://github.com/trinodb/trino/issues/12289
204    # https://github.com/prestodb/presto/issues/2863
205    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
206
207    class Tokenizer(tokens.Tokenizer):
208        UNICODE_STRINGS = [
209            (prefix + q, q)
210            for q in t.cast(t.List[str], tokens.Tokenizer.QUOTES)
211            for prefix in ("U&", "u&")
212        ]
213
214        KEYWORDS = {
215            **tokens.Tokenizer.KEYWORDS,
216            "START": TokenType.BEGIN,
217            "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
218            "ROW": TokenType.STRUCT,
219            "IPADDRESS": TokenType.IPADDRESS,
220            "IPPREFIX": TokenType.IPPREFIX,
221        }
222
223    class Parser(parser.Parser):
224        VALUES_FOLLOWED_BY_PAREN = False
225
226        FUNCTIONS = {
227            **parser.Parser.FUNCTIONS,
228            "ARBITRARY": exp.AnyValue.from_arg_list,
229            "APPROX_DISTINCT": exp.ApproxDistinct.from_arg_list,
230            "APPROX_PERCENTILE": _build_approx_percentile,
231            "BITWISE_AND": binary_from_function(exp.BitwiseAnd),
232            "BITWISE_NOT": lambda args: exp.BitwiseNot(this=seq_get(args, 0)),
233            "BITWISE_OR": binary_from_function(exp.BitwiseOr),
234            "BITWISE_XOR": binary_from_function(exp.BitwiseXor),
235            "CARDINALITY": exp.ArraySize.from_arg_list,
236            "CONTAINS": exp.ArrayContains.from_arg_list,
237            "DATE_ADD": lambda args: exp.DateAdd(
238                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
239            ),
240            "DATE_DIFF": lambda args: exp.DateDiff(
241                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
242            ),
243            "DATE_FORMAT": build_formatted_time(exp.TimeToStr, "presto"),
244            "DATE_PARSE": build_formatted_time(exp.StrToTime, "presto"),
245            "DATE_TRUNC": date_trunc_to_time,
246            "ELEMENT_AT": lambda args: exp.Bracket(
247                this=seq_get(args, 0), expressions=[seq_get(args, 1)], offset=1, safe=True
248            ),
249            "FROM_HEX": exp.Unhex.from_arg_list,
250            "FROM_UNIXTIME": _build_from_unixtime,
251            "FROM_UTF8": lambda args: exp.Decode(
252                this=seq_get(args, 0), replace=seq_get(args, 1), charset=exp.Literal.string("utf-8")
253            ),
254            "NOW": exp.CurrentTimestamp.from_arg_list,
255            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
256                this=seq_get(args, 0), expression=seq_get(args, 1), group=seq_get(args, 2)
257            ),
258            "REGEXP_REPLACE": lambda args: exp.RegexpReplace(
259                this=seq_get(args, 0),
260                expression=seq_get(args, 1),
261                replacement=seq_get(args, 2) or exp.Literal.string(""),
262            ),
263            "ROW": exp.Struct.from_arg_list,
264            "SEQUENCE": exp.GenerateSeries.from_arg_list,
265            "SET_AGG": exp.ArrayUniqueAgg.from_arg_list,
266            "SPLIT_TO_MAP": exp.StrToMap.from_arg_list,
267            "STRPOS": lambda args: exp.StrPosition(
268                this=seq_get(args, 0), substr=seq_get(args, 1), instance=seq_get(args, 2)
269            ),
270            "TO_CHAR": _build_to_char,
271            "TO_HEX": exp.Hex.from_arg_list,
272            "TO_UNIXTIME": exp.TimeToUnix.from_arg_list,
273            "TO_UTF8": lambda args: exp.Encode(
274                this=seq_get(args, 0), charset=exp.Literal.string("utf-8")
275            ),
276        }
277
278        FUNCTION_PARSERS = parser.Parser.FUNCTION_PARSERS.copy()
279        FUNCTION_PARSERS.pop("TRIM")
280
281    class Generator(generator.Generator):
282        INTERVAL_ALLOWS_PLURAL_FORM = False
283        JOIN_HINTS = False
284        TABLE_HINTS = False
285        QUERY_HINTS = False
286        IS_BOOL_ALLOWED = False
287        TZ_TO_WITH_TIME_ZONE = True
288        NVL2_SUPPORTED = False
289        STRUCT_DELIMITER = ("(", ")")
290        LIMIT_ONLY_LITERALS = True
291        SUPPORTS_SINGLE_ARG_CONCAT = False
292        LIKE_PROPERTY_INSIDE_SCHEMA = True
293        MULTI_ARG_DISTINCT = False
294        SUPPORTS_TO_NUMBER = False
295
296        PROPERTIES_LOCATION = {
297            **generator.Generator.PROPERTIES_LOCATION,
298            exp.LocationProperty: exp.Properties.Location.UNSUPPORTED,
299            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
300        }
301
302        TYPE_MAPPING = {
303            **generator.Generator.TYPE_MAPPING,
304            exp.DataType.Type.INT: "INTEGER",
305            exp.DataType.Type.FLOAT: "REAL",
306            exp.DataType.Type.BINARY: "VARBINARY",
307            exp.DataType.Type.TEXT: "VARCHAR",
308            exp.DataType.Type.TIMETZ: "TIME",
309            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
310            exp.DataType.Type.STRUCT: "ROW",
311            exp.DataType.Type.DATETIME: "TIMESTAMP",
312            exp.DataType.Type.DATETIME64: "TIMESTAMP",
313        }
314
315        TRANSFORMS = {
316            **generator.Generator.TRANSFORMS,
317            exp.AnyValue: rename_func("ARBITRARY"),
318            exp.ApproxDistinct: lambda self, e: self.func(
319                "APPROX_DISTINCT", e.this, e.args.get("accuracy")
320            ),
321            exp.ApproxQuantile: rename_func("APPROX_PERCENTILE"),
322            exp.ArgMax: rename_func("MAX_BY"),
323            exp.ArgMin: rename_func("MIN_BY"),
324            exp.Array: lambda self, e: f"ARRAY[{self.expressions(e, flat=True)}]",
325            exp.ArrayAny: rename_func("ANY_MATCH"),
326            exp.ArrayConcat: rename_func("CONCAT"),
327            exp.ArrayContains: rename_func("CONTAINS"),
328            exp.ArraySize: rename_func("CARDINALITY"),
329            exp.ArrayToString: rename_func("ARRAY_JOIN"),
330            exp.ArrayUniqueAgg: rename_func("SET_AGG"),
331            exp.AtTimeZone: rename_func("AT_TIMEZONE"),
332            exp.BitwiseAnd: lambda self, e: self.func("BITWISE_AND", e.this, e.expression),
333            exp.BitwiseLeftShift: lambda self, e: self.func(
334                "BITWISE_ARITHMETIC_SHIFT_LEFT", e.this, e.expression
335            ),
336            exp.BitwiseNot: lambda self, e: self.func("BITWISE_NOT", e.this),
337            exp.BitwiseOr: lambda self, e: self.func("BITWISE_OR", e.this, e.expression),
338            exp.BitwiseRightShift: lambda self, e: self.func(
339                "BITWISE_ARITHMETIC_SHIFT_RIGHT", e.this, e.expression
340            ),
341            exp.BitwiseXor: lambda self, e: self.func("BITWISE_XOR", e.this, e.expression),
342            exp.Cast: transforms.preprocess([transforms.epoch_cast_to_ts]),
343            exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",
344            exp.DateAdd: lambda self, e: self.func(
345                "DATE_ADD",
346                exp.Literal.string(e.text("unit") or "DAY"),
347                _to_int(e.expression),
348                e.this,
349            ),
350            exp.DateDiff: lambda self, e: self.func(
351                "DATE_DIFF", exp.Literal.string(e.text("unit") or "DAY"), e.expression, e.this
352            ),
353            exp.DateStrToDate: datestrtodate_sql,
354            exp.DateToDi: lambda self,
355            e: f"CAST(DATE_FORMAT({self.sql(e, 'this')}, {Presto.DATEINT_FORMAT}) AS INT)",
356            exp.DateSub: lambda self, e: self.func(
357                "DATE_ADD",
358                exp.Literal.string(e.text("unit") or "DAY"),
359                _to_int(e.expression * -1),
360                e.this,
361            ),
362            exp.Decode: lambda self, e: encode_decode_sql(self, e, "FROM_UTF8"),
363            exp.DiToDate: lambda self,
364            e: f"CAST(DATE_PARSE(CAST({self.sql(e, 'this')} AS VARCHAR), {Presto.DATEINT_FORMAT}) AS DATE)",
365            exp.Encode: lambda self, e: encode_decode_sql(self, e, "TO_UTF8"),
366            exp.FileFormatProperty: lambda self, e: f"FORMAT='{e.name.upper()}'",
367            exp.First: _first_last_sql,
368            exp.FirstValue: _first_last_sql,
369            exp.FromTimeZone: lambda self,
370            e: f"WITH_TIMEZONE({self.sql(e, 'this')}, {self.sql(e, 'zone')}) AT TIME ZONE 'UTC'",
371            exp.Group: transforms.preprocess([transforms.unalias_group]),
372            exp.GroupConcat: lambda self, e: self.func(
373                "ARRAY_JOIN", self.func("ARRAY_AGG", e.this), e.args.get("separator")
374            ),
375            exp.Hex: rename_func("TO_HEX"),
376            exp.If: if_sql(),
377            exp.ILike: no_ilike_sql,
378            exp.Initcap: _initcap_sql,
379            exp.ParseJSON: rename_func("JSON_PARSE"),
380            exp.Last: _first_last_sql,
381            exp.LastValue: _first_last_sql,
382            exp.LastDay: lambda self, e: self.func("LAST_DAY_OF_MONTH", e.this),
383            exp.Lateral: _explode_to_unnest_sql,
384            exp.Left: left_to_substring_sql,
385            exp.Levenshtein: rename_func("LEVENSHTEIN_DISTANCE"),
386            exp.LogicalAnd: rename_func("BOOL_AND"),
387            exp.LogicalOr: rename_func("BOOL_OR"),
388            exp.Pivot: no_pivot_sql,
389            exp.Quantile: _quantile_sql,
390            exp.RegexpExtract: regexp_extract_sql,
391            exp.Right: right_to_substring_sql,
392            exp.SafeDivide: no_safe_divide_sql,
393            exp.Schema: _schema_sql,
394            exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
395            exp.Select: transforms.preprocess(
396                [
397                    transforms.eliminate_qualify,
398                    transforms.eliminate_distinct_on,
399                    transforms.explode_to_unnest(1),
400                    transforms.eliminate_semi_and_anti_joins,
401                ]
402            ),
403            exp.SortArray: _no_sort_array,
404            exp.StrPosition: rename_func("STRPOS"),
405            exp.StrToDate: lambda self, e: f"CAST({_str_to_time_sql(self, e)} AS DATE)",
406            exp.StrToMap: rename_func("SPLIT_TO_MAP"),
407            exp.StrToTime: _str_to_time_sql,
408            exp.StructExtract: struct_extract_sql,
409            exp.Table: transforms.preprocess([_unnest_sequence]),
410            exp.Timestamp: no_timestamp_sql,
411            exp.TimestampTrunc: timestamptrunc_sql,
412            exp.TimeStrToDate: timestrtotime_sql,
413            exp.TimeStrToTime: timestrtotime_sql,
414            exp.TimeStrToUnix: lambda self, e: self.func(
415                "TO_UNIXTIME", self.func("DATE_PARSE", e.this, Presto.TIME_FORMAT)
416            ),
417            exp.TimeToStr: lambda self, e: self.func("DATE_FORMAT", e.this, self.format_time(e)),
418            exp.TimeToUnix: rename_func("TO_UNIXTIME"),
419            exp.ToChar: lambda self, e: self.func("DATE_FORMAT", e.this, self.format_time(e)),
420            exp.TryCast: transforms.preprocess([transforms.epoch_cast_to_ts]),
421            exp.TsOrDiToDi: lambda self,
422            e: f"CAST(SUBSTR(REPLACE(CAST({self.sql(e, 'this')} AS VARCHAR), '-', ''), 1, 8) AS INT)",
423            exp.TsOrDsAdd: _ts_or_ds_add_sql,
424            exp.TsOrDsDiff: _ts_or_ds_diff_sql,
425            exp.TsOrDsToDate: _ts_or_ds_to_date_sql,
426            exp.Unhex: rename_func("FROM_HEX"),
427            exp.UnixToStr: lambda self,
428            e: f"DATE_FORMAT(FROM_UNIXTIME({self.sql(e, 'this')}), {self.format_time(e)})",
429            exp.UnixToTime: _unix_to_time_sql,
430            exp.UnixToTimeStr: lambda self,
431            e: f"CAST(FROM_UNIXTIME({self.sql(e, 'this')}) AS VARCHAR)",
432            exp.VariancePop: rename_func("VAR_POP"),
433            exp.With: transforms.preprocess([transforms.add_recursive_cte_column_names]),
434            exp.WithinGroup: transforms.preprocess(
435                [transforms.remove_within_group_for_percentiles]
436            ),
437            exp.Xor: bool_xor_sql,
438        }
439
440        def strtounix_sql(self, expression: exp.StrToUnix) -> str:
441            # Since `TO_UNIXTIME` requires a `TIMESTAMP`, we need to parse the argument into one.
442            # To do this, we first try to `DATE_PARSE` it, but since this can fail when there's a
443            # timezone involved, we wrap it in a `TRY` call and use `PARSE_DATETIME` as a fallback,
444            # which seems to be using the same time mapping as Hive, as per:
445            # https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html
446            value_as_text = exp.cast(expression.this, "text")
447            parse_without_tz = self.func("DATE_PARSE", value_as_text, self.format_time(expression))
448            parse_with_tz = self.func(
449                "PARSE_DATETIME",
450                value_as_text,
451                self.format_time(expression, Hive.INVERSE_TIME_MAPPING, Hive.INVERSE_TIME_TRIE),
452            )
453            coalesced = self.func("COALESCE", self.func("TRY", parse_without_tz), parse_with_tz)
454            return self.func("TO_UNIXTIME", coalesced)
455
456        def bracket_sql(self, expression: exp.Bracket) -> str:
457            if expression.args.get("safe"):
458                return self.func(
459                    "ELEMENT_AT",
460                    expression.this,
461                    seq_get(
462                        apply_index_offset(
463                            expression.this,
464                            expression.expressions,
465                            1 - expression.args.get("offset", 0),
466                        ),
467                        0,
468                    ),
469                )
470            return super().bracket_sql(expression)
471
472        def struct_sql(self, expression: exp.Struct) -> str:
473            from sqlglot.optimizer.annotate_types import annotate_types
474
475            expression = annotate_types(expression)
476            values: t.List[str] = []
477            schema: t.List[str] = []
478            unknown_type = False
479
480            for e in expression.expressions:
481                if isinstance(e, exp.PropertyEQ):
482                    if e.type and e.type.is_type(exp.DataType.Type.UNKNOWN):
483                        unknown_type = True
484                    else:
485                        schema.append(f"{self.sql(e, 'this')} {self.sql(e.type)}")
486                    values.append(self.sql(e, "expression"))
487                else:
488                    values.append(self.sql(e))
489
490            size = len(expression.expressions)
491
492            if not size or len(schema) != size:
493                if unknown_type:
494                    self.unsupported(
495                        "Cannot convert untyped key-value definitions (try annotate_types)."
496                    )
497                return self.func("ROW", *values)
498            return f"CAST(ROW({', '.join(values)}) AS ROW({', '.join(schema)}))"
499
500        def interval_sql(self, expression: exp.Interval) -> str:
501            unit = self.sql(expression, "unit")
502            if expression.this and unit.startswith("WEEK"):
503                return f"({expression.this.name} * INTERVAL '7' DAY)"
504            return super().interval_sql(expression)
505
506        def transaction_sql(self, expression: exp.Transaction) -> str:
507            modes = expression.args.get("modes")
508            modes = f" {', '.join(modes)}" if modes else ""
509            return f"START TRANSACTION{modes}"
510
511        def generateseries_sql(self, expression: exp.GenerateSeries) -> str:
512            start = expression.args["start"]
513            end = expression.args["end"]
514            step = expression.args.get("step")
515
516            if isinstance(start, exp.Cast):
517                target_type = start.to
518            elif isinstance(end, exp.Cast):
519                target_type = end.to
520            else:
521                target_type = None
522
523            if target_type and target_type.is_type("timestamp"):
524                if target_type is start.to:
525                    end = exp.cast(end, target_type)
526                else:
527                    start = exp.cast(start, target_type)
528
529            return self.func("SEQUENCE", start, end, step)
530
531        def offset_limit_modifiers(
532            self, expression: exp.Expression, fetch: bool, limit: t.Optional[exp.Fetch | exp.Limit]
533        ) -> t.List[str]:
534            return [
535                self.sql(expression, "offset"),
536                self.sql(limit),
537            ]
538
539        def create_sql(self, expression: exp.Create) -> str:
540            """
541            Presto doesn't support CREATE VIEW with expressions (ex: `CREATE VIEW x (cola)` then `(cola)` is the expression),
542            so we need to remove them
543            """
544            kind = expression.args["kind"]
545            schema = expression.this
546            if kind == "VIEW" and schema.expressions:
547                expression.this.set("expressions", None)
548            return super().create_sql(expression)