sqlglot.dialects.mysql

  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    arrow_json_extract_scalar_sql,
 10    date_add_interval_sql,
 11    datestrtodate_sql,
 12    format_time_lambda,
 13    isnull_to_is_null,
 14    json_keyvalue_comma_sql,
 15    locate_to_strposition,
 16    max_or_greatest,
 17    min_or_least,
 18    no_ilike_sql,
 19    no_paren_current_date_sql,
 20    no_pivot_sql,
 21    no_tablesample_sql,
 22    no_trycast_sql,
 23    parse_date_delta_with_interval,
 24    rename_func,
 25    strposition_to_locate_sql,
 26)
 27from sqlglot.helper import seq_get
 28from sqlglot.tokens import TokenType
 29
 30
 31def _show_parser(*args: t.Any, **kwargs: t.Any) -> t.Callable[[MySQL.Parser], exp.Show]:
 32    def _parse(self: MySQL.Parser) -> exp.Show:
 33        return self._parse_show_mysql(*args, **kwargs)
 34
 35    return _parse
 36
 37
 38def _date_trunc_sql(self: MySQL.Generator, expression: exp.DateTrunc) -> str:
 39    expr = self.sql(expression, "this")
 40    unit = expression.text("unit")
 41
 42    if unit == "day":
 43        return f"DATE({expr})"
 44
 45    if unit == "week":
 46        concat = f"CONCAT(YEAR({expr}), ' ', WEEK({expr}, 1), ' 1')"
 47        date_format = "%Y %u %w"
 48    elif unit == "month":
 49        concat = f"CONCAT(YEAR({expr}), ' ', MONTH({expr}), ' 1')"
 50        date_format = "%Y %c %e"
 51    elif unit == "quarter":
 52        concat = f"CONCAT(YEAR({expr}), ' ', QUARTER({expr}) * 3 - 2, ' 1')"
 53        date_format = "%Y %c %e"
 54    elif unit == "year":
 55        concat = f"CONCAT(YEAR({expr}), ' 1 1')"
 56        date_format = "%Y %c %e"
 57    else:
 58        self.unsupported(f"Unexpected interval unit: {unit}")
 59        return f"DATE({expr})"
 60
 61    return f"STR_TO_DATE({concat}, '{date_format}')"
 62
 63
 64# All specifiers for time parts (as opposed to date parts)
 65# https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_date-format
 66TIME_SPECIFIERS = {"f", "H", "h", "I", "i", "k", "l", "p", "r", "S", "s", "T"}
 67
 68
 69def _has_time_specifier(date_format: str) -> bool:
 70    i = 0
 71    length = len(date_format)
 72
 73    while i < length:
 74        if date_format[i] == "%":
 75            i += 1
 76            if i < length and date_format[i] in TIME_SPECIFIERS:
 77                return True
 78        i += 1
 79    return False
 80
 81
 82def _str_to_date(args: t.List) -> exp.StrToDate | exp.StrToTime:
 83    mysql_date_format = seq_get(args, 1)
 84    date_format = MySQL.format_time(mysql_date_format)
 85    this = seq_get(args, 0)
 86
 87    if mysql_date_format and _has_time_specifier(mysql_date_format.name):
 88        return exp.StrToTime(this=this, format=date_format)
 89
 90    return exp.StrToDate(this=this, format=date_format)
 91
 92
 93def _str_to_date_sql(
 94    self: MySQL.Generator, expression: exp.StrToDate | exp.StrToTime | exp.TsOrDsToDate
 95) -> str:
 96    date_format = self.format_time(expression)
 97    return f"STR_TO_DATE({self.sql(expression.this)}, {date_format})"
 98
 99
100def _trim_sql(self: MySQL.Generator, expression: exp.Trim) -> str:
101    target = self.sql(expression, "this")
102    trim_type = self.sql(expression, "position")
103    remove_chars = self.sql(expression, "expression")
104
105    # Use TRIM/LTRIM/RTRIM syntax if the expression isn't mysql-specific
106    if not remove_chars:
107        return self.trim_sql(expression)
108
109    trim_type = f"{trim_type} " if trim_type else ""
110    remove_chars = f"{remove_chars} " if remove_chars else ""
111    from_part = "FROM " if trim_type or remove_chars else ""
112    return f"TRIM({trim_type}{remove_chars}{from_part}{target})"
113
114
115def _date_add_sql(
116    kind: str,
117) -> t.Callable[[MySQL.Generator, exp.Expression], str]:
118    def func(self: MySQL.Generator, expression: exp.Expression) -> str:
119        this = self.sql(expression, "this")
120        unit = expression.text("unit").upper() or "DAY"
121        return (
122            f"DATE_{kind}({this}, {self.sql(exp.Interval(this=expression.expression, unit=unit))})"
123        )
124
125    return func
126
127
128def _ts_or_ds_to_date_sql(self: MySQL.Generator, expression: exp.TsOrDsToDate) -> str:
129    time_format = expression.args.get("format")
130    if time_format:
131        return _str_to_date_sql(self, expression)
132    return f"DATE({self.sql(expression, 'this')})"
133
134
135def _remove_ts_or_ds_to_date(
136    to_sql: t.Optional[t.Callable[[MySQL.Generator, exp.Expression], str]] = None,
137    args: t.Tuple[str, ...] = ("this",),
138) -> t.Callable[[MySQL.Generator, exp.Func], str]:
139    def func(self: MySQL.Generator, expression: exp.Func) -> str:
140        for arg_key in args:
141            arg = expression.args.get(arg_key)
142            if isinstance(arg, exp.TsOrDsToDate) and not arg.args.get("format"):
143                expression.set(arg_key, arg.this)
144
145        return to_sql(self, expression) if to_sql else self.function_fallback_sql(expression)
146
147    return func
148
149
150class MySQL(Dialect):
151    # https://dev.mysql.com/doc/refman/8.0/en/identifiers.html
152    IDENTIFIERS_CAN_START_WITH_DIGIT = True
153
154    # We default to treating all identifiers as case-sensitive, since it matches MySQL's
155    # behavior on Linux systems. For MacOS and Windows systems, one can override this
156    # setting by specifying `dialect="mysql, normalization_strategy = lowercase"`.
157    #
158    # See also https://dev.mysql.com/doc/refman/8.2/en/identifier-case-sensitivity.html
159    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_SENSITIVE
160
161    TIME_FORMAT = "'%Y-%m-%d %T'"
162    DPIPE_IS_STRING_CONCAT = False
163    SUPPORTS_USER_DEFINED_TYPES = False
164    SUPPORTS_SEMI_ANTI_JOIN = False
165    SAFE_DIVISION = True
166
167    # https://prestodb.io/docs/current/functions/datetime.html#mysql-date-functions
168    TIME_MAPPING = {
169        "%M": "%B",
170        "%c": "%-m",
171        "%e": "%-d",
172        "%h": "%I",
173        "%i": "%M",
174        "%s": "%S",
175        "%u": "%W",
176        "%k": "%-H",
177        "%l": "%-I",
178        "%T": "%H:%M:%S",
179        "%W": "%a",
180    }
181
182    class Tokenizer(tokens.Tokenizer):
183        QUOTES = ["'", '"']
184        COMMENTS = ["--", "#", ("/*", "*/")]
185        IDENTIFIERS = ["`"]
186        STRING_ESCAPES = ["'", '"', "\\"]
187        BIT_STRINGS = [("b'", "'"), ("B'", "'"), ("0b", "")]
188        HEX_STRINGS = [("x'", "'"), ("X'", "'"), ("0x", "")]
189
190        KEYWORDS = {
191            **tokens.Tokenizer.KEYWORDS,
192            "CHARSET": TokenType.CHARACTER_SET,
193            "ENUM": TokenType.ENUM,
194            "FORCE": TokenType.FORCE,
195            "IGNORE": TokenType.IGNORE,
196            "LOCK TABLES": TokenType.COMMAND,
197            "LONGBLOB": TokenType.LONGBLOB,
198            "LONGTEXT": TokenType.LONGTEXT,
199            "MEDIUMBLOB": TokenType.MEDIUMBLOB,
200            "TINYBLOB": TokenType.TINYBLOB,
201            "TINYTEXT": TokenType.TINYTEXT,
202            "MEDIUMTEXT": TokenType.MEDIUMTEXT,
203            "MEDIUMINT": TokenType.MEDIUMINT,
204            "MEMBER OF": TokenType.MEMBER_OF,
205            "SEPARATOR": TokenType.SEPARATOR,
206            "START": TokenType.BEGIN,
207            "SIGNED": TokenType.BIGINT,
208            "SIGNED INTEGER": TokenType.BIGINT,
209            "UNLOCK TABLES": TokenType.COMMAND,
210            "UNSIGNED": TokenType.UBIGINT,
211            "UNSIGNED INTEGER": TokenType.UBIGINT,
212            "YEAR": TokenType.YEAR,
213            "_ARMSCII8": TokenType.INTRODUCER,
214            "_ASCII": TokenType.INTRODUCER,
215            "_BIG5": TokenType.INTRODUCER,
216            "_BINARY": TokenType.INTRODUCER,
217            "_CP1250": TokenType.INTRODUCER,
218            "_CP1251": TokenType.INTRODUCER,
219            "_CP1256": TokenType.INTRODUCER,
220            "_CP1257": TokenType.INTRODUCER,
221            "_CP850": TokenType.INTRODUCER,
222            "_CP852": TokenType.INTRODUCER,
223            "_CP866": TokenType.INTRODUCER,
224            "_CP932": TokenType.INTRODUCER,
225            "_DEC8": TokenType.INTRODUCER,
226            "_EUCJPMS": TokenType.INTRODUCER,
227            "_EUCKR": TokenType.INTRODUCER,
228            "_GB18030": TokenType.INTRODUCER,
229            "_GB2312": TokenType.INTRODUCER,
230            "_GBK": TokenType.INTRODUCER,
231            "_GEOSTD8": TokenType.INTRODUCER,
232            "_GREEK": TokenType.INTRODUCER,
233            "_HEBREW": TokenType.INTRODUCER,
234            "_HP8": TokenType.INTRODUCER,
235            "_KEYBCS2": TokenType.INTRODUCER,
236            "_KOI8R": TokenType.INTRODUCER,
237            "_KOI8U": TokenType.INTRODUCER,
238            "_LATIN1": TokenType.INTRODUCER,
239            "_LATIN2": TokenType.INTRODUCER,
240            "_LATIN5": TokenType.INTRODUCER,
241            "_LATIN7": TokenType.INTRODUCER,
242            "_MACCE": TokenType.INTRODUCER,
243            "_MACROMAN": TokenType.INTRODUCER,
244            "_SJIS": TokenType.INTRODUCER,
245            "_SWE7": TokenType.INTRODUCER,
246            "_TIS620": TokenType.INTRODUCER,
247            "_UCS2": TokenType.INTRODUCER,
248            "_UJIS": TokenType.INTRODUCER,
249            # https://dev.mysql.com/doc/refman/8.0/en/string-literals.html
250            "_UTF8": TokenType.INTRODUCER,
251            "_UTF16": TokenType.INTRODUCER,
252            "_UTF16LE": TokenType.INTRODUCER,
253            "_UTF32": TokenType.INTRODUCER,
254            "_UTF8MB3": TokenType.INTRODUCER,
255            "_UTF8MB4": TokenType.INTRODUCER,
256            "@@": TokenType.SESSION_PARAMETER,
257        }
258
259        COMMANDS = tokens.Tokenizer.COMMANDS - {TokenType.SHOW}
260
261    class Parser(parser.Parser):
262        FUNC_TOKENS = {
263            *parser.Parser.FUNC_TOKENS,
264            TokenType.DATABASE,
265            TokenType.SCHEMA,
266            TokenType.VALUES,
267        }
268
269        CONJUNCTION = {
270            **parser.Parser.CONJUNCTION,
271            TokenType.DAMP: exp.And,
272            TokenType.XOR: exp.Xor,
273            TokenType.DPIPE: exp.Or,
274        }
275
276        TABLE_ALIAS_TOKENS = (
277            parser.Parser.TABLE_ALIAS_TOKENS - parser.Parser.TABLE_INDEX_HINT_TOKENS
278        )
279
280        RANGE_PARSERS = {
281            **parser.Parser.RANGE_PARSERS,
282            TokenType.MEMBER_OF: lambda self, this: self.expression(
283                exp.JSONArrayContains,
284                this=this,
285                expression=self._parse_wrapped(self._parse_expression),
286            ),
287        }
288
289        FUNCTIONS = {
290            **parser.Parser.FUNCTIONS,
291            "DATE": lambda args: exp.TsOrDsToDate(this=seq_get(args, 0)),
292            "DATE_ADD": parse_date_delta_with_interval(exp.DateAdd),
293            "DATE_FORMAT": format_time_lambda(exp.TimeToStr, "mysql"),
294            "DATE_SUB": parse_date_delta_with_interval(exp.DateSub),
295            "INSTR": lambda args: exp.StrPosition(substr=seq_get(args, 1), this=seq_get(args, 0)),
296            "ISNULL": isnull_to_is_null,
297            "LOCATE": locate_to_strposition,
298            "MONTHNAME": lambda args: exp.TimeToStr(
299                this=exp.TsOrDsToDate(this=seq_get(args, 0)),
300                format=exp.Literal.string("%B"),
301            ),
302            "STR_TO_DATE": _str_to_date,
303            "TO_DAYS": lambda args: exp.paren(
304                exp.DateDiff(
305                    this=exp.TsOrDsToDate(this=seq_get(args, 0)),
306                    expression=exp.TsOrDsToDate(this=exp.Literal.string("0000-01-01")),
307                    unit=exp.var("DAY"),
308                )
309                + 1
310            ),
311            "DAY": lambda args: exp.Day(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
312            "DAYOFMONTH": lambda args: exp.DayOfMonth(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
313            "DAYOFWEEK": lambda args: exp.DayOfWeek(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
314            "DAYOFYEAR": lambda args: exp.DayOfYear(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
315            "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
316            "WEEK": lambda args: exp.Week(
317                this=exp.TsOrDsToDate(this=seq_get(args, 0)), mode=seq_get(args, 1)
318            ),
319            "WEEKOFYEAR": lambda args: exp.WeekOfYear(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
320            "YEAR": lambda args: exp.Year(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
321        }
322
323        FUNCTION_PARSERS = {
324            **parser.Parser.FUNCTION_PARSERS,
325            "CHAR": lambda self: self._parse_chr(),
326            "GROUP_CONCAT": lambda self: self.expression(
327                exp.GroupConcat,
328                this=self._parse_lambda(),
329                separator=self._match(TokenType.SEPARATOR) and self._parse_field(),
330            ),
331            # https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_values
332            "VALUES": lambda self: self.expression(
333                exp.Anonymous, this="VALUES", expressions=[self._parse_id_var()]
334            ),
335        }
336
337        STATEMENT_PARSERS = {
338            **parser.Parser.STATEMENT_PARSERS,
339            TokenType.SHOW: lambda self: self._parse_show(),
340        }
341
342        SHOW_PARSERS = {
343            "BINARY LOGS": _show_parser("BINARY LOGS"),
344            "MASTER LOGS": _show_parser("BINARY LOGS"),
345            "BINLOG EVENTS": _show_parser("BINLOG EVENTS"),
346            "CHARACTER SET": _show_parser("CHARACTER SET"),
347            "CHARSET": _show_parser("CHARACTER SET"),
348            "COLLATION": _show_parser("COLLATION"),
349            "FULL COLUMNS": _show_parser("COLUMNS", target="FROM", full=True),
350            "COLUMNS": _show_parser("COLUMNS", target="FROM"),
351            "CREATE DATABASE": _show_parser("CREATE DATABASE", target=True),
352            "CREATE EVENT": _show_parser("CREATE EVENT", target=True),
353            "CREATE FUNCTION": _show_parser("CREATE FUNCTION", target=True),
354            "CREATE PROCEDURE": _show_parser("CREATE PROCEDURE", target=True),
355            "CREATE TABLE": _show_parser("CREATE TABLE", target=True),
356            "CREATE TRIGGER": _show_parser("CREATE TRIGGER", target=True),
357            "CREATE VIEW": _show_parser("CREATE VIEW", target=True),
358            "DATABASES": _show_parser("DATABASES"),
359            "ENGINE": _show_parser("ENGINE", target=True),
360            "STORAGE ENGINES": _show_parser("ENGINES"),
361            "ENGINES": _show_parser("ENGINES"),
362            "ERRORS": _show_parser("ERRORS"),
363            "EVENTS": _show_parser("EVENTS"),
364            "FUNCTION CODE": _show_parser("FUNCTION CODE", target=True),
365            "FUNCTION STATUS": _show_parser("FUNCTION STATUS"),
366            "GRANTS": _show_parser("GRANTS", target="FOR"),
367            "INDEX": _show_parser("INDEX", target="FROM"),
368            "MASTER STATUS": _show_parser("MASTER STATUS"),
369            "OPEN TABLES": _show_parser("OPEN TABLES"),
370            "PLUGINS": _show_parser("PLUGINS"),
371            "PROCEDURE CODE": _show_parser("PROCEDURE CODE", target=True),
372            "PROCEDURE STATUS": _show_parser("PROCEDURE STATUS"),
373            "PRIVILEGES": _show_parser("PRIVILEGES"),
374            "FULL PROCESSLIST": _show_parser("PROCESSLIST", full=True),
375            "PROCESSLIST": _show_parser("PROCESSLIST"),
376            "PROFILE": _show_parser("PROFILE"),
377            "PROFILES": _show_parser("PROFILES"),
378            "RELAYLOG EVENTS": _show_parser("RELAYLOG EVENTS"),
379            "REPLICAS": _show_parser("REPLICAS"),
380            "SLAVE HOSTS": _show_parser("REPLICAS"),
381            "REPLICA STATUS": _show_parser("REPLICA STATUS"),
382            "SLAVE STATUS": _show_parser("REPLICA STATUS"),
383            "GLOBAL STATUS": _show_parser("STATUS", global_=True),
384            "SESSION STATUS": _show_parser("STATUS"),
385            "STATUS": _show_parser("STATUS"),
386            "TABLE STATUS": _show_parser("TABLE STATUS"),
387            "FULL TABLES": _show_parser("TABLES", full=True),
388            "TABLES": _show_parser("TABLES"),
389            "TRIGGERS": _show_parser("TRIGGERS"),
390            "GLOBAL VARIABLES": _show_parser("VARIABLES", global_=True),
391            "SESSION VARIABLES": _show_parser("VARIABLES"),
392            "VARIABLES": _show_parser("VARIABLES"),
393            "WARNINGS": _show_parser("WARNINGS"),
394        }
395
396        SET_PARSERS = {
397            **parser.Parser.SET_PARSERS,
398            "PERSIST": lambda self: self._parse_set_item_assignment("PERSIST"),
399            "PERSIST_ONLY": lambda self: self._parse_set_item_assignment("PERSIST_ONLY"),
400            "CHARACTER SET": lambda self: self._parse_set_item_charset("CHARACTER SET"),
401            "CHARSET": lambda self: self._parse_set_item_charset("CHARACTER SET"),
402            "NAMES": lambda self: self._parse_set_item_names(),
403        }
404
405        CONSTRAINT_PARSERS = {
406            **parser.Parser.CONSTRAINT_PARSERS,
407            "FULLTEXT": lambda self: self._parse_index_constraint(kind="FULLTEXT"),
408            "INDEX": lambda self: self._parse_index_constraint(),
409            "KEY": lambda self: self._parse_index_constraint(),
410            "SPATIAL": lambda self: self._parse_index_constraint(kind="SPATIAL"),
411        }
412
413        SCHEMA_UNNAMED_CONSTRAINTS = {
414            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
415            "FULLTEXT",
416            "INDEX",
417            "KEY",
418            "SPATIAL",
419        }
420
421        PROFILE_TYPES = {
422            "ALL",
423            "BLOCK IO",
424            "CONTEXT SWITCHES",
425            "CPU",
426            "IPC",
427            "MEMORY",
428            "PAGE FAULTS",
429            "SOURCE",
430            "SWAPS",
431        }
432
433        TYPE_TOKENS = {
434            *parser.Parser.TYPE_TOKENS,
435            TokenType.SET,
436        }
437
438        ENUM_TYPE_TOKENS = {
439            *parser.Parser.ENUM_TYPE_TOKENS,
440            TokenType.SET,
441        }
442
443        LOG_DEFAULTS_TO_LN = True
444
445        def _parse_primary_key_part(self) -> t.Optional[exp.Expression]:
446            this = self._parse_id_var()
447            if not self._match(TokenType.L_PAREN):
448                return this
449
450            expression = self._parse_number()
451            self._match_r_paren()
452            return self.expression(exp.ColumnPrefix, this=this, expression=expression)
453
454        def _parse_index_constraint(
455            self, kind: t.Optional[str] = None
456        ) -> exp.IndexColumnConstraint:
457            if kind:
458                self._match_texts(("INDEX", "KEY"))
459
460            this = self._parse_id_var(any_token=False)
461            index_type = self._match(TokenType.USING) and self._advance_any() and self._prev.text
462            schema = self._parse_schema()
463
464            options = []
465            while True:
466                if self._match_text_seq("KEY_BLOCK_SIZE"):
467                    self._match(TokenType.EQ)
468                    opt = exp.IndexConstraintOption(key_block_size=self._parse_number())
469                elif self._match(TokenType.USING):
470                    opt = exp.IndexConstraintOption(using=self._advance_any() and self._prev.text)
471                elif self._match_text_seq("WITH", "PARSER"):
472                    opt = exp.IndexConstraintOption(parser=self._parse_var(any_token=True))
473                elif self._match(TokenType.COMMENT):
474                    opt = exp.IndexConstraintOption(comment=self._parse_string())
475                elif self._match_text_seq("VISIBLE"):
476                    opt = exp.IndexConstraintOption(visible=True)
477                elif self._match_text_seq("INVISIBLE"):
478                    opt = exp.IndexConstraintOption(visible=False)
479                elif self._match_text_seq("ENGINE_ATTRIBUTE"):
480                    self._match(TokenType.EQ)
481                    opt = exp.IndexConstraintOption(engine_attr=self._parse_string())
482                elif self._match_text_seq("ENGINE_ATTRIBUTE"):
483                    self._match(TokenType.EQ)
484                    opt = exp.IndexConstraintOption(engine_attr=self._parse_string())
485                elif self._match_text_seq("SECONDARY_ENGINE_ATTRIBUTE"):
486                    self._match(TokenType.EQ)
487                    opt = exp.IndexConstraintOption(secondary_engine_attr=self._parse_string())
488                else:
489                    opt = None
490
491                if not opt:
492                    break
493
494                options.append(opt)
495
496            return self.expression(
497                exp.IndexColumnConstraint,
498                this=this,
499                schema=schema,
500                kind=kind,
501                index_type=index_type,
502                options=options,
503            )
504
505        def _parse_show_mysql(
506            self,
507            this: str,
508            target: bool | str = False,
509            full: t.Optional[bool] = None,
510            global_: t.Optional[bool] = None,
511        ) -> exp.Show:
512            if target:
513                if isinstance(target, str):
514                    self._match_text_seq(target)
515                target_id = self._parse_id_var()
516            else:
517                target_id = None
518
519            log = self._parse_string() if self._match_text_seq("IN") else None
520
521            if this in ("BINLOG EVENTS", "RELAYLOG EVENTS"):
522                position = self._parse_number() if self._match_text_seq("FROM") else None
523                db = None
524            else:
525                position = None
526                db = None
527
528                if self._match(TokenType.FROM):
529                    db = self._parse_id_var()
530                elif self._match(TokenType.DOT):
531                    db = target_id
532                    target_id = self._parse_id_var()
533
534            channel = self._parse_id_var() if self._match_text_seq("FOR", "CHANNEL") else None
535
536            like = self._parse_string() if self._match_text_seq("LIKE") else None
537            where = self._parse_where()
538
539            if this == "PROFILE":
540                types = self._parse_csv(lambda: self._parse_var_from_options(self.PROFILE_TYPES))
541                query = self._parse_number() if self._match_text_seq("FOR", "QUERY") else None
542                offset = self._parse_number() if self._match_text_seq("OFFSET") else None
543                limit = self._parse_number() if self._match_text_seq("LIMIT") else None
544            else:
545                types, query = None, None
546                offset, limit = self._parse_oldstyle_limit()
547
548            mutex = True if self._match_text_seq("MUTEX") else None
549            mutex = False if self._match_text_seq("STATUS") else mutex
550
551            return self.expression(
552                exp.Show,
553                this=this,
554                target=target_id,
555                full=full,
556                log=log,
557                position=position,
558                db=db,
559                channel=channel,
560                like=like,
561                where=where,
562                types=types,
563                query=query,
564                offset=offset,
565                limit=limit,
566                mutex=mutex,
567                **{"global": global_},  # type: ignore
568            )
569
570        def _parse_oldstyle_limit(
571            self,
572        ) -> t.Tuple[t.Optional[exp.Expression], t.Optional[exp.Expression]]:
573            limit = None
574            offset = None
575            if self._match_text_seq("LIMIT"):
576                parts = self._parse_csv(self._parse_number)
577                if len(parts) == 1:
578                    limit = parts[0]
579                elif len(parts) == 2:
580                    limit = parts[1]
581                    offset = parts[0]
582
583            return offset, limit
584
585        def _parse_set_item_charset(self, kind: str) -> exp.Expression:
586            this = self._parse_string() or self._parse_id_var()
587            return self.expression(exp.SetItem, this=this, kind=kind)
588
589        def _parse_set_item_names(self) -> exp.Expression:
590            charset = self._parse_string() or self._parse_id_var()
591            if self._match_text_seq("COLLATE"):
592                collate = self._parse_string() or self._parse_id_var()
593            else:
594                collate = None
595
596            return self.expression(exp.SetItem, this=charset, collate=collate, kind="NAMES")
597
598        def _parse_type(self, parse_interval: bool = True) -> t.Optional[exp.Expression]:
599            # mysql binary is special and can work anywhere, even in order by operations
600            # it operates like a no paren func
601            if self._match(TokenType.BINARY, advance=False):
602                data_type = self._parse_types(check_func=True, allow_identifiers=False)
603
604                if isinstance(data_type, exp.DataType):
605                    return self.expression(exp.Cast, this=self._parse_column(), to=data_type)
606
607            return super()._parse_type(parse_interval=parse_interval)
608
609        def _parse_chr(self) -> t.Optional[exp.Expression]:
610            expressions = self._parse_csv(self._parse_conjunction)
611            kwargs: t.Dict[str, t.Any] = {"this": seq_get(expressions, 0)}
612
613            if len(expressions) > 1:
614                kwargs["expressions"] = expressions[1:]
615
616            if self._match(TokenType.USING):
617                kwargs["charset"] = self._parse_var()
618
619            return self.expression(exp.Chr, **kwargs)
620
621    class Generator(generator.Generator):
622        LOCKING_READS_SUPPORTED = True
623        NULL_ORDERING_SUPPORTED = False
624        JOIN_HINTS = False
625        TABLE_HINTS = True
626        DUPLICATE_KEY_UPDATE_WITH_SET = False
627        QUERY_HINT_SEP = " "
628        VALUES_AS_TABLE = False
629        NVL2_SUPPORTED = False
630
631        TRANSFORMS = {
632            **generator.Generator.TRANSFORMS,
633            exp.CurrentDate: no_paren_current_date_sql,
634            exp.DateDiff: _remove_ts_or_ds_to_date(
635                lambda self, e: self.func("DATEDIFF", e.this, e.expression), ("this", "expression")
636            ),
637            exp.DateAdd: _remove_ts_or_ds_to_date(_date_add_sql("ADD")),
638            exp.DateStrToDate: datestrtodate_sql,
639            exp.DateSub: _remove_ts_or_ds_to_date(_date_add_sql("SUB")),
640            exp.DateTrunc: _date_trunc_sql,
641            exp.Day: _remove_ts_or_ds_to_date(),
642            exp.DayOfMonth: _remove_ts_or_ds_to_date(rename_func("DAYOFMONTH")),
643            exp.DayOfWeek: _remove_ts_or_ds_to_date(rename_func("DAYOFWEEK")),
644            exp.DayOfYear: _remove_ts_or_ds_to_date(rename_func("DAYOFYEAR")),
645            exp.GroupConcat: lambda self, e: f"""GROUP_CONCAT({self.sql(e, "this")} SEPARATOR {self.sql(e, "separator") or "','"})""",
646            exp.ILike: no_ilike_sql,
647            exp.JSONExtractScalar: arrow_json_extract_scalar_sql,
648            exp.JSONKeyValue: json_keyvalue_comma_sql,
649            exp.Max: max_or_greatest,
650            exp.Min: min_or_least,
651            exp.Month: _remove_ts_or_ds_to_date(),
652            exp.NullSafeEQ: lambda self, e: self.binary(e, "<=>"),
653            exp.NullSafeNEQ: lambda self, e: self.not_sql(self.binary(e, "<=>")),
654            exp.Pivot: no_pivot_sql,
655            exp.Select: transforms.preprocess(
656                [
657                    transforms.eliminate_distinct_on,
658                    transforms.eliminate_semi_and_anti_joins,
659                    transforms.eliminate_qualify,
660                    transforms.eliminate_full_outer_join,
661                ]
662            ),
663            exp.StrPosition: strposition_to_locate_sql,
664            exp.StrToDate: _str_to_date_sql,
665            exp.StrToTime: _str_to_date_sql,
666            exp.Stuff: rename_func("INSERT"),
667            exp.TableSample: no_tablesample_sql,
668            exp.TimestampAdd: date_add_interval_sql("DATE", "ADD"),
669            exp.TimestampSub: date_add_interval_sql("DATE", "SUB"),
670            exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
671            exp.TimeStrToTime: lambda self, e: self.sql(exp.cast(e.this, "datetime", copy=True)),
672            exp.TimeToStr: _remove_ts_or_ds_to_date(
673                lambda self, e: self.func("DATE_FORMAT", e.this, self.format_time(e))
674            ),
675            exp.Trim: _trim_sql,
676            exp.TryCast: no_trycast_sql,
677            exp.TsOrDsAdd: _date_add_sql("ADD"),
678            exp.TsOrDsDiff: lambda self, e: self.func("DATEDIFF", e.this, e.expression),
679            exp.TsOrDsToDate: _ts_or_ds_to_date_sql,
680            exp.Week: _remove_ts_or_ds_to_date(),
681            exp.WeekOfYear: _remove_ts_or_ds_to_date(rename_func("WEEKOFYEAR")),
682            exp.Year: _remove_ts_or_ds_to_date(),
683        }
684
685        UNSIGNED_TYPE_MAPPING = {
686            exp.DataType.Type.UBIGINT: "BIGINT",
687            exp.DataType.Type.UINT: "INT",
688            exp.DataType.Type.UMEDIUMINT: "MEDIUMINT",
689            exp.DataType.Type.USMALLINT: "SMALLINT",
690            exp.DataType.Type.UTINYINT: "TINYINT",
691            exp.DataType.Type.UDECIMAL: "DECIMAL",
692        }
693
694        TIMESTAMP_TYPE_MAPPING = {
695            exp.DataType.Type.TIMESTAMP: "DATETIME",
696            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
697            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
698        }
699
700        TYPE_MAPPING = {
701            **generator.Generator.TYPE_MAPPING,
702            **UNSIGNED_TYPE_MAPPING,
703            **TIMESTAMP_TYPE_MAPPING,
704        }
705
706        TYPE_MAPPING.pop(exp.DataType.Type.MEDIUMTEXT)
707        TYPE_MAPPING.pop(exp.DataType.Type.LONGTEXT)
708        TYPE_MAPPING.pop(exp.DataType.Type.TINYTEXT)
709        TYPE_MAPPING.pop(exp.DataType.Type.MEDIUMBLOB)
710        TYPE_MAPPING.pop(exp.DataType.Type.LONGBLOB)
711        TYPE_MAPPING.pop(exp.DataType.Type.TINYBLOB)
712
713        PROPERTIES_LOCATION = {
714            **generator.Generator.PROPERTIES_LOCATION,
715            exp.TransientProperty: exp.Properties.Location.UNSUPPORTED,
716            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
717        }
718
719        LIMIT_FETCH = "LIMIT"
720
721        LIMIT_ONLY_LITERALS = True
722
723        # MySQL doesn't support many datatypes in cast.
724        # https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html#function_cast
725        CAST_MAPPING = {
726            exp.DataType.Type.BIGINT: "SIGNED",
727            exp.DataType.Type.BOOLEAN: "SIGNED",
728            exp.DataType.Type.INT: "SIGNED",
729            exp.DataType.Type.TEXT: "CHAR",
730            exp.DataType.Type.UBIGINT: "UNSIGNED",
731            exp.DataType.Type.VARCHAR: "CHAR",
732        }
733
734        TIMESTAMP_FUNC_TYPES = {
735            exp.DataType.Type.TIMESTAMPTZ,
736            exp.DataType.Type.TIMESTAMPLTZ,
737        }
738
739        def datatype_sql(self, expression: exp.DataType) -> str:
740            # https://dev.mysql.com/doc/refman/8.0/en/numeric-type-syntax.html
741            result = super().datatype_sql(expression)
742            if expression.this in self.UNSIGNED_TYPE_MAPPING:
743                result = f"{result} UNSIGNED"
744            return result
745
746        def xor_sql(self, expression: exp.Xor) -> str:
747            if expression.expressions:
748                return self.expressions(expression, sep=" XOR ")
749            return super().xor_sql(expression)
750
751        def jsonarraycontains_sql(self, expression: exp.JSONArrayContains) -> str:
752            return f"{self.sql(expression, 'this')} MEMBER OF({self.sql(expression, 'expression')})"
753
754        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
755            if expression.to.this in self.TIMESTAMP_FUNC_TYPES:
756                return self.func("TIMESTAMP", expression.this)
757
758            to = self.CAST_MAPPING.get(expression.to.this)
759
760            if to:
761                expression.to.set("this", to)
762            return super().cast_sql(expression)
763
764        def show_sql(self, expression: exp.Show) -> str:
765            this = f" {expression.name}"
766            full = " FULL" if expression.args.get("full") else ""
767            global_ = " GLOBAL" if expression.args.get("global") else ""
768
769            target = self.sql(expression, "target")
770            target = f" {target}" if target else ""
771            if expression.name in ("COLUMNS", "INDEX"):
772                target = f" FROM{target}"
773            elif expression.name == "GRANTS":
774                target = f" FOR{target}"
775
776            db = self._prefixed_sql("FROM", expression, "db")
777
778            like = self._prefixed_sql("LIKE", expression, "like")
779            where = self.sql(expression, "where")
780
781            types = self.expressions(expression, key="types")
782            types = f" {types}" if types else types
783            query = self._prefixed_sql("FOR QUERY", expression, "query")
784
785            if expression.name == "PROFILE":
786                offset = self._prefixed_sql("OFFSET", expression, "offset")
787                limit = self._prefixed_sql("LIMIT", expression, "limit")
788            else:
789                offset = ""
790                limit = self._oldstyle_limit_sql(expression)
791
792            log = self._prefixed_sql("IN", expression, "log")
793            position = self._prefixed_sql("FROM", expression, "position")
794
795            channel = self._prefixed_sql("FOR CHANNEL", expression, "channel")
796
797            if expression.name == "ENGINE":
798                mutex_or_status = " MUTEX" if expression.args.get("mutex") else " STATUS"
799            else:
800                mutex_or_status = ""
801
802            return f"SHOW{full}{global_}{this}{target}{types}{db}{query}{log}{position}{channel}{mutex_or_status}{like}{where}{offset}{limit}"
803
804        def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
805            dtype = self.sql(expression, "dtype")
806            if not dtype:
807                return super().altercolumn_sql(expression)
808
809            this = self.sql(expression, "this")
810            return f"MODIFY COLUMN {this} {dtype}"
811
812        def _prefixed_sql(self, prefix: str, expression: exp.Expression, arg: str) -> str:
813            sql = self.sql(expression, arg)
814            return f" {prefix} {sql}" if sql else ""
815
816        def _oldstyle_limit_sql(self, expression: exp.Show) -> str:
817            limit = self.sql(expression, "limit")
818            offset = self.sql(expression, "offset")
819            if limit:
820                limit_offset = f"{offset}, {limit}" if offset else limit
821                return f" LIMIT {limit_offset}"
822            return ""
823
824        def chr_sql(self, expression: exp.Chr) -> str:
825            this = self.expressions(sqls=[expression.this] + expression.expressions)
826            charset = expression.args.get("charset")
827            using = f" USING {self.sql(charset)}" if charset else ""
828            return f"CHAR({this}{using})"