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_sql,
  10    date_add_interval_sql,
  11    datestrtodate_sql,
  12    build_formatted_time,
  13    isnull_to_is_null,
  14    length_or_char_length_sql,
  15    max_or_greatest,
  16    min_or_least,
  17    no_ilike_sql,
  18    no_paren_current_date_sql,
  19    no_pivot_sql,
  20    no_tablesample_sql,
  21    no_trycast_sql,
  22    build_date_delta,
  23    build_date_delta_with_interval,
  24    rename_func,
  25    strposition_sql,
  26    unit_to_var,
  27    trim_sql,
  28    timestrtotime_sql,
  29)
  30from sqlglot.helper import seq_get
  31from sqlglot.tokens import TokenType
  32
  33
  34def _show_parser(*args: t.Any, **kwargs: t.Any) -> t.Callable[[MySQL.Parser], exp.Show]:
  35    def _parse(self: MySQL.Parser) -> exp.Show:
  36        return self._parse_show_mysql(*args, **kwargs)
  37
  38    return _parse
  39
  40
  41def _date_trunc_sql(self: MySQL.Generator, expression: exp.DateTrunc) -> str:
  42    expr = self.sql(expression, "this")
  43    unit = expression.text("unit").upper()
  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        if unit != "DAY":
  59            self.unsupported(f"Unexpected interval unit: {unit}")
  60        return self.func("DATE", expr)
  61
  62    return self.func("STR_TO_DATE", concat, f"'{date_format}'")
  63
  64
  65# All specifiers for time parts (as opposed to date parts)
  66# https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_date-format
  67TIME_SPECIFIERS = {"f", "H", "h", "I", "i", "k", "l", "p", "r", "S", "s", "T"}
  68
  69
  70def _has_time_specifier(date_format: str) -> bool:
  71    i = 0
  72    length = len(date_format)
  73
  74    while i < length:
  75        if date_format[i] == "%":
  76            i += 1
  77            if i < length and date_format[i] in TIME_SPECIFIERS:
  78                return True
  79        i += 1
  80    return False
  81
  82
  83def _str_to_date(args: t.List) -> exp.StrToDate | exp.StrToTime:
  84    mysql_date_format = seq_get(args, 1)
  85    date_format = MySQL.format_time(mysql_date_format)
  86    this = seq_get(args, 0)
  87
  88    if mysql_date_format and _has_time_specifier(mysql_date_format.name):
  89        return exp.StrToTime(this=this, format=date_format)
  90
  91    return exp.StrToDate(this=this, format=date_format)
  92
  93
  94def _str_to_date_sql(
  95    self: MySQL.Generator, expression: exp.StrToDate | exp.StrToTime | exp.TsOrDsToDate
  96) -> str:
  97    return self.func("STR_TO_DATE", expression.this, self.format_time(expression))
  98
  99
 100def _unix_to_time_sql(self: MySQL.Generator, expression: exp.UnixToTime) -> str:
 101    scale = expression.args.get("scale")
 102    timestamp = expression.this
 103
 104    if scale in (None, exp.UnixToTime.SECONDS):
 105        return self.func("FROM_UNIXTIME", timestamp, self.format_time(expression))
 106
 107    return self.func(
 108        "FROM_UNIXTIME",
 109        exp.Div(this=timestamp, expression=exp.func("POW", 10, scale)),
 110        self.format_time(expression),
 111    )
 112
 113
 114def date_add_sql(
 115    kind: str,
 116) -> t.Callable[[generator.Generator, exp.Expression], str]:
 117    def func(self: generator.Generator, expression: exp.Expression) -> str:
 118        return self.func(
 119            f"DATE_{kind}",
 120            expression.this,
 121            exp.Interval(this=expression.expression, unit=unit_to_var(expression)),
 122        )
 123
 124    return func
 125
 126
 127def _ts_or_ds_to_date_sql(self: MySQL.Generator, expression: exp.TsOrDsToDate) -> str:
 128    time_format = expression.args.get("format")
 129    return _str_to_date_sql(self, expression) if time_format else self.func("DATE", expression.this)
 130
 131
 132def _remove_ts_or_ds_to_date(
 133    to_sql: t.Optional[t.Callable[[MySQL.Generator, exp.Expression], str]] = None,
 134    args: t.Tuple[str, ...] = ("this",),
 135) -> t.Callable[[MySQL.Generator, exp.Func], str]:
 136    def func(self: MySQL.Generator, expression: exp.Func) -> str:
 137        for arg_key in args:
 138            arg = expression.args.get(arg_key)
 139            if isinstance(arg, exp.TsOrDsToDate) and not arg.args.get("format"):
 140                expression.set(arg_key, arg.this)
 141
 142        return to_sql(self, expression) if to_sql else self.function_fallback_sql(expression)
 143
 144    return func
 145
 146
 147class MySQL(Dialect):
 148    PROMOTE_TO_INFERRED_DATETIME_TYPE = True
 149
 150    # https://dev.mysql.com/doc/refman/8.0/en/identifiers.html
 151    IDENTIFIERS_CAN_START_WITH_DIGIT = True
 152
 153    # We default to treating all identifiers as case-sensitive, since it matches MySQL's
 154    # behavior on Linux systems. For MacOS and Windows systems, one can override this
 155    # setting by specifying `dialect="mysql, normalization_strategy = lowercase"`.
 156    #
 157    # See also https://dev.mysql.com/doc/refman/8.2/en/identifier-case-sensitivity.html
 158    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_SENSITIVE
 159
 160    TIME_FORMAT = "'%Y-%m-%d %T'"
 161    DPIPE_IS_STRING_CONCAT = False
 162    SUPPORTS_USER_DEFINED_TYPES = False
 163    SUPPORTS_SEMI_ANTI_JOIN = False
 164    SAFE_DIVISION = True
 165
 166    # https://prestodb.io/docs/current/functions/datetime.html#mysql-date-functions
 167    TIME_MAPPING = {
 168        "%M": "%B",
 169        "%c": "%-m",
 170        "%e": "%-d",
 171        "%h": "%I",
 172        "%i": "%M",
 173        "%s": "%S",
 174        "%u": "%W",
 175        "%k": "%-H",
 176        "%l": "%-I",
 177        "%T": "%H:%M:%S",
 178        "%W": "%A",
 179    }
 180
 181    class Tokenizer(tokens.Tokenizer):
 182        QUOTES = ["'", '"']
 183        COMMENTS = ["--", "#", ("/*", "*/")]
 184        IDENTIFIERS = ["`"]
 185        STRING_ESCAPES = ["'", '"', "\\"]
 186        BIT_STRINGS = [("b'", "'"), ("B'", "'"), ("0b", "")]
 187        HEX_STRINGS = [("x'", "'"), ("X'", "'"), ("0x", "")]
 188
 189        KEYWORDS = {
 190            **tokens.Tokenizer.KEYWORDS,
 191            "CHARSET": TokenType.CHARACTER_SET,
 192            # The DESCRIBE and EXPLAIN statements are synonyms.
 193            # https://dev.mysql.com/doc/refman/8.4/en/explain.html
 194            "EXPLAIN": TokenType.DESCRIBE,
 195            "FORCE": TokenType.FORCE,
 196            "IGNORE": TokenType.IGNORE,
 197            "KEY": TokenType.KEY,
 198            "LOCK TABLES": TokenType.COMMAND,
 199            "LONGBLOB": TokenType.LONGBLOB,
 200            "LONGTEXT": TokenType.LONGTEXT,
 201            "MEDIUMBLOB": TokenType.MEDIUMBLOB,
 202            "TINYBLOB": TokenType.TINYBLOB,
 203            "TINYTEXT": TokenType.TINYTEXT,
 204            "MEDIUMTEXT": TokenType.MEDIUMTEXT,
 205            "MEDIUMINT": TokenType.MEDIUMINT,
 206            "MEMBER OF": TokenType.MEMBER_OF,
 207            "SEPARATOR": TokenType.SEPARATOR,
 208            "SERIAL": TokenType.SERIAL,
 209            "START": TokenType.BEGIN,
 210            "SIGNED": TokenType.BIGINT,
 211            "SIGNED INTEGER": TokenType.BIGINT,
 212            "UNLOCK TABLES": TokenType.COMMAND,
 213            "UNSIGNED": TokenType.UBIGINT,
 214            "UNSIGNED INTEGER": TokenType.UBIGINT,
 215            "YEAR": TokenType.YEAR,
 216            "_ARMSCII8": TokenType.INTRODUCER,
 217            "_ASCII": TokenType.INTRODUCER,
 218            "_BIG5": TokenType.INTRODUCER,
 219            "_BINARY": TokenType.INTRODUCER,
 220            "_CP1250": TokenType.INTRODUCER,
 221            "_CP1251": TokenType.INTRODUCER,
 222            "_CP1256": TokenType.INTRODUCER,
 223            "_CP1257": TokenType.INTRODUCER,
 224            "_CP850": TokenType.INTRODUCER,
 225            "_CP852": TokenType.INTRODUCER,
 226            "_CP866": TokenType.INTRODUCER,
 227            "_CP932": TokenType.INTRODUCER,
 228            "_DEC8": TokenType.INTRODUCER,
 229            "_EUCJPMS": TokenType.INTRODUCER,
 230            "_EUCKR": TokenType.INTRODUCER,
 231            "_GB18030": TokenType.INTRODUCER,
 232            "_GB2312": TokenType.INTRODUCER,
 233            "_GBK": TokenType.INTRODUCER,
 234            "_GEOSTD8": TokenType.INTRODUCER,
 235            "_GREEK": TokenType.INTRODUCER,
 236            "_HEBREW": TokenType.INTRODUCER,
 237            "_HP8": TokenType.INTRODUCER,
 238            "_KEYBCS2": TokenType.INTRODUCER,
 239            "_KOI8R": TokenType.INTRODUCER,
 240            "_KOI8U": TokenType.INTRODUCER,
 241            "_LATIN1": TokenType.INTRODUCER,
 242            "_LATIN2": TokenType.INTRODUCER,
 243            "_LATIN5": TokenType.INTRODUCER,
 244            "_LATIN7": TokenType.INTRODUCER,
 245            "_MACCE": TokenType.INTRODUCER,
 246            "_MACROMAN": TokenType.INTRODUCER,
 247            "_SJIS": TokenType.INTRODUCER,
 248            "_SWE7": TokenType.INTRODUCER,
 249            "_TIS620": TokenType.INTRODUCER,
 250            "_UCS2": TokenType.INTRODUCER,
 251            "_UJIS": TokenType.INTRODUCER,
 252            # https://dev.mysql.com/doc/refman/8.0/en/string-literals.html
 253            "_UTF8": TokenType.INTRODUCER,
 254            "_UTF16": TokenType.INTRODUCER,
 255            "_UTF16LE": TokenType.INTRODUCER,
 256            "_UTF32": TokenType.INTRODUCER,
 257            "_UTF8MB3": TokenType.INTRODUCER,
 258            "_UTF8MB4": TokenType.INTRODUCER,
 259            "@@": TokenType.SESSION_PARAMETER,
 260        }
 261
 262        COMMANDS = {*tokens.Tokenizer.COMMANDS, TokenType.REPLACE} - {TokenType.SHOW}
 263
 264    class Parser(parser.Parser):
 265        FUNC_TOKENS = {
 266            *parser.Parser.FUNC_TOKENS,
 267            TokenType.DATABASE,
 268            TokenType.SCHEMA,
 269            TokenType.VALUES,
 270        }
 271
 272        CONJUNCTION = {
 273            **parser.Parser.CONJUNCTION,
 274            TokenType.DAMP: exp.And,
 275            TokenType.XOR: exp.Xor,
 276        }
 277
 278        DISJUNCTION = {
 279            **parser.Parser.DISJUNCTION,
 280            TokenType.DPIPE: exp.Or,
 281        }
 282
 283        TABLE_ALIAS_TOKENS = (
 284            parser.Parser.TABLE_ALIAS_TOKENS - parser.Parser.TABLE_INDEX_HINT_TOKENS
 285        )
 286
 287        RANGE_PARSERS = {
 288            **parser.Parser.RANGE_PARSERS,
 289            TokenType.MEMBER_OF: lambda self, this: self.expression(
 290                exp.JSONArrayContains,
 291                this=this,
 292                expression=self._parse_wrapped(self._parse_expression),
 293            ),
 294        }
 295
 296        FUNCTIONS = {
 297            **parser.Parser.FUNCTIONS,
 298            "CONVERT_TZ": lambda args: exp.ConvertTimezone(
 299                source_tz=seq_get(args, 1), target_tz=seq_get(args, 2), timestamp=seq_get(args, 0)
 300            ),
 301            "DATE": lambda args: exp.TsOrDsToDate(this=seq_get(args, 0)),
 302            "DATE_ADD": build_date_delta_with_interval(exp.DateAdd),
 303            "DATE_FORMAT": build_formatted_time(exp.TimeToStr, "mysql"),
 304            "DATE_SUB": build_date_delta_with_interval(exp.DateSub),
 305            "DAY": lambda args: exp.Day(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
 306            "DAYOFMONTH": lambda args: exp.DayOfMonth(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
 307            "DAYOFWEEK": lambda args: exp.DayOfWeek(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
 308            "DAYOFYEAR": lambda args: exp.DayOfYear(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
 309            "FORMAT": exp.NumberToStr.from_arg_list,
 310            "FROM_UNIXTIME": build_formatted_time(exp.UnixToTime, "mysql"),
 311            "ISNULL": isnull_to_is_null,
 312            "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
 313            "MAKETIME": exp.TimeFromParts.from_arg_list,
 314            "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
 315            "MONTHNAME": lambda args: exp.TimeToStr(
 316                this=exp.TsOrDsToDate(this=seq_get(args, 0)),
 317                format=exp.Literal.string("%B"),
 318            ),
 319            "STR_TO_DATE": _str_to_date,
 320            "TIMESTAMPDIFF": build_date_delta(exp.TimestampDiff),
 321            "TO_DAYS": lambda args: exp.paren(
 322                exp.DateDiff(
 323                    this=exp.TsOrDsToDate(this=seq_get(args, 0)),
 324                    expression=exp.TsOrDsToDate(this=exp.Literal.string("0000-01-01")),
 325                    unit=exp.var("DAY"),
 326                )
 327                + 1
 328            ),
 329            "WEEK": lambda args: exp.Week(
 330                this=exp.TsOrDsToDate(this=seq_get(args, 0)), mode=seq_get(args, 1)
 331            ),
 332            "WEEKOFYEAR": lambda args: exp.WeekOfYear(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
 333            "YEAR": lambda args: exp.Year(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
 334        }
 335
 336        FUNCTION_PARSERS = {
 337            **parser.Parser.FUNCTION_PARSERS,
 338            "CHAR": lambda self: self.expression(
 339                exp.Chr,
 340                expressions=self._parse_csv(self._parse_assignment),
 341                charset=self._match(TokenType.USING) and self._parse_var(),
 342            ),
 343            "GROUP_CONCAT": lambda self: self._parse_group_concat(),
 344            # https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_values
 345            "VALUES": lambda self: self.expression(
 346                exp.Anonymous, this="VALUES", expressions=[self._parse_id_var()]
 347            ),
 348            "JSON_VALUE": lambda self: self._parse_json_value(),
 349        }
 350
 351        STATEMENT_PARSERS = {
 352            **parser.Parser.STATEMENT_PARSERS,
 353            TokenType.SHOW: lambda self: self._parse_show(),
 354        }
 355
 356        SHOW_PARSERS = {
 357            "BINARY LOGS": _show_parser("BINARY LOGS"),
 358            "MASTER LOGS": _show_parser("BINARY LOGS"),
 359            "BINLOG EVENTS": _show_parser("BINLOG EVENTS"),
 360            "CHARACTER SET": _show_parser("CHARACTER SET"),
 361            "CHARSET": _show_parser("CHARACTER SET"),
 362            "COLLATION": _show_parser("COLLATION"),
 363            "FULL COLUMNS": _show_parser("COLUMNS", target="FROM", full=True),
 364            "COLUMNS": _show_parser("COLUMNS", target="FROM"),
 365            "CREATE DATABASE": _show_parser("CREATE DATABASE", target=True),
 366            "CREATE EVENT": _show_parser("CREATE EVENT", target=True),
 367            "CREATE FUNCTION": _show_parser("CREATE FUNCTION", target=True),
 368            "CREATE PROCEDURE": _show_parser("CREATE PROCEDURE", target=True),
 369            "CREATE TABLE": _show_parser("CREATE TABLE", target=True),
 370            "CREATE TRIGGER": _show_parser("CREATE TRIGGER", target=True),
 371            "CREATE VIEW": _show_parser("CREATE VIEW", target=True),
 372            "DATABASES": _show_parser("DATABASES"),
 373            "SCHEMAS": _show_parser("DATABASES"),
 374            "ENGINE": _show_parser("ENGINE", target=True),
 375            "STORAGE ENGINES": _show_parser("ENGINES"),
 376            "ENGINES": _show_parser("ENGINES"),
 377            "ERRORS": _show_parser("ERRORS"),
 378            "EVENTS": _show_parser("EVENTS"),
 379            "FUNCTION CODE": _show_parser("FUNCTION CODE", target=True),
 380            "FUNCTION STATUS": _show_parser("FUNCTION STATUS"),
 381            "GRANTS": _show_parser("GRANTS", target="FOR"),
 382            "INDEX": _show_parser("INDEX", target="FROM"),
 383            "MASTER STATUS": _show_parser("MASTER STATUS"),
 384            "OPEN TABLES": _show_parser("OPEN TABLES"),
 385            "PLUGINS": _show_parser("PLUGINS"),
 386            "PROCEDURE CODE": _show_parser("PROCEDURE CODE", target=True),
 387            "PROCEDURE STATUS": _show_parser("PROCEDURE STATUS"),
 388            "PRIVILEGES": _show_parser("PRIVILEGES"),
 389            "FULL PROCESSLIST": _show_parser("PROCESSLIST", full=True),
 390            "PROCESSLIST": _show_parser("PROCESSLIST"),
 391            "PROFILE": _show_parser("PROFILE"),
 392            "PROFILES": _show_parser("PROFILES"),
 393            "RELAYLOG EVENTS": _show_parser("RELAYLOG EVENTS"),
 394            "REPLICAS": _show_parser("REPLICAS"),
 395            "SLAVE HOSTS": _show_parser("REPLICAS"),
 396            "REPLICA STATUS": _show_parser("REPLICA STATUS"),
 397            "SLAVE STATUS": _show_parser("REPLICA STATUS"),
 398            "GLOBAL STATUS": _show_parser("STATUS", global_=True),
 399            "SESSION STATUS": _show_parser("STATUS"),
 400            "STATUS": _show_parser("STATUS"),
 401            "TABLE STATUS": _show_parser("TABLE STATUS"),
 402            "FULL TABLES": _show_parser("TABLES", full=True),
 403            "TABLES": _show_parser("TABLES"),
 404            "TRIGGERS": _show_parser("TRIGGERS"),
 405            "GLOBAL VARIABLES": _show_parser("VARIABLES", global_=True),
 406            "SESSION VARIABLES": _show_parser("VARIABLES"),
 407            "VARIABLES": _show_parser("VARIABLES"),
 408            "WARNINGS": _show_parser("WARNINGS"),
 409        }
 410
 411        PROPERTY_PARSERS = {
 412            **parser.Parser.PROPERTY_PARSERS,
 413            "LOCK": lambda self: self._parse_property_assignment(exp.LockProperty),
 414        }
 415
 416        SET_PARSERS = {
 417            **parser.Parser.SET_PARSERS,
 418            "PERSIST": lambda self: self._parse_set_item_assignment("PERSIST"),
 419            "PERSIST_ONLY": lambda self: self._parse_set_item_assignment("PERSIST_ONLY"),
 420            "CHARACTER SET": lambda self: self._parse_set_item_charset("CHARACTER SET"),
 421            "CHARSET": lambda self: self._parse_set_item_charset("CHARACTER SET"),
 422            "NAMES": lambda self: self._parse_set_item_names(),
 423        }
 424
 425        CONSTRAINT_PARSERS = {
 426            **parser.Parser.CONSTRAINT_PARSERS,
 427            "FULLTEXT": lambda self: self._parse_index_constraint(kind="FULLTEXT"),
 428            "INDEX": lambda self: self._parse_index_constraint(),
 429            "KEY": lambda self: self._parse_index_constraint(),
 430            "SPATIAL": lambda self: self._parse_index_constraint(kind="SPATIAL"),
 431        }
 432
 433        ALTER_PARSERS = {
 434            **parser.Parser.ALTER_PARSERS,
 435            "MODIFY": lambda self: self._parse_alter_table_alter(),
 436        }
 437
 438        SCHEMA_UNNAMED_CONSTRAINTS = {
 439            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
 440            "FULLTEXT",
 441            "INDEX",
 442            "KEY",
 443            "SPATIAL",
 444        }
 445
 446        PROFILE_TYPES: parser.OPTIONS_TYPE = {
 447            **dict.fromkeys(("ALL", "CPU", "IPC", "MEMORY", "SOURCE", "SWAPS"), tuple()),
 448            "BLOCK": ("IO",),
 449            "CONTEXT": ("SWITCHES",),
 450            "PAGE": ("FAULTS",),
 451        }
 452
 453        TYPE_TOKENS = {
 454            *parser.Parser.TYPE_TOKENS,
 455            TokenType.SET,
 456        }
 457
 458        ENUM_TYPE_TOKENS = {
 459            *parser.Parser.ENUM_TYPE_TOKENS,
 460            TokenType.SET,
 461        }
 462
 463        # SELECT [ ALL | DISTINCT | DISTINCTROW ] [ <OPERATION_MODIFIERS> ]
 464        OPERATION_MODIFIERS = {
 465            "HIGH_PRIORITY",
 466            "STRAIGHT_JOIN",
 467            "SQL_SMALL_RESULT",
 468            "SQL_BIG_RESULT",
 469            "SQL_BUFFER_RESULT",
 470            "SQL_NO_CACHE",
 471            "SQL_CALC_FOUND_ROWS",
 472        }
 473
 474        LOG_DEFAULTS_TO_LN = True
 475        STRING_ALIASES = True
 476        VALUES_FOLLOWED_BY_PAREN = False
 477        SUPPORTS_PARTITION_SELECTION = True
 478
 479        def _parse_primary_key_part(self) -> t.Optional[exp.Expression]:
 480            this = self._parse_id_var()
 481            if not self._match(TokenType.L_PAREN):
 482                return this
 483
 484            expression = self._parse_number()
 485            self._match_r_paren()
 486            return self.expression(exp.ColumnPrefix, this=this, expression=expression)
 487
 488        def _parse_index_constraint(
 489            self, kind: t.Optional[str] = None
 490        ) -> exp.IndexColumnConstraint:
 491            if kind:
 492                self._match_texts(("INDEX", "KEY"))
 493
 494            this = self._parse_id_var(any_token=False)
 495            index_type = self._match(TokenType.USING) and self._advance_any() and self._prev.text
 496            expressions = self._parse_wrapped_csv(self._parse_ordered)
 497
 498            options = []
 499            while True:
 500                if self._match_text_seq("KEY_BLOCK_SIZE"):
 501                    self._match(TokenType.EQ)
 502                    opt = exp.IndexConstraintOption(key_block_size=self._parse_number())
 503                elif self._match(TokenType.USING):
 504                    opt = exp.IndexConstraintOption(using=self._advance_any() and self._prev.text)
 505                elif self._match_text_seq("WITH", "PARSER"):
 506                    opt = exp.IndexConstraintOption(parser=self._parse_var(any_token=True))
 507                elif self._match(TokenType.COMMENT):
 508                    opt = exp.IndexConstraintOption(comment=self._parse_string())
 509                elif self._match_text_seq("VISIBLE"):
 510                    opt = exp.IndexConstraintOption(visible=True)
 511                elif self._match_text_seq("INVISIBLE"):
 512                    opt = exp.IndexConstraintOption(visible=False)
 513                elif self._match_text_seq("ENGINE_ATTRIBUTE"):
 514                    self._match(TokenType.EQ)
 515                    opt = exp.IndexConstraintOption(engine_attr=self._parse_string())
 516                elif self._match_text_seq("SECONDARY_ENGINE_ATTRIBUTE"):
 517                    self._match(TokenType.EQ)
 518                    opt = exp.IndexConstraintOption(secondary_engine_attr=self._parse_string())
 519                else:
 520                    opt = None
 521
 522                if not opt:
 523                    break
 524
 525                options.append(opt)
 526
 527            return self.expression(
 528                exp.IndexColumnConstraint,
 529                this=this,
 530                expressions=expressions,
 531                kind=kind,
 532                index_type=index_type,
 533                options=options,
 534            )
 535
 536        def _parse_show_mysql(
 537            self,
 538            this: str,
 539            target: bool | str = False,
 540            full: t.Optional[bool] = None,
 541            global_: t.Optional[bool] = None,
 542        ) -> exp.Show:
 543            if target:
 544                if isinstance(target, str):
 545                    self._match_text_seq(target)
 546                target_id = self._parse_id_var()
 547            else:
 548                target_id = None
 549
 550            log = self._parse_string() if self._match_text_seq("IN") else None
 551
 552            if this in ("BINLOG EVENTS", "RELAYLOG EVENTS"):
 553                position = self._parse_number() if self._match_text_seq("FROM") else None
 554                db = None
 555            else:
 556                position = None
 557                db = None
 558
 559                if self._match(TokenType.FROM):
 560                    db = self._parse_id_var()
 561                elif self._match(TokenType.DOT):
 562                    db = target_id
 563                    target_id = self._parse_id_var()
 564
 565            channel = self._parse_id_var() if self._match_text_seq("FOR", "CHANNEL") else None
 566
 567            like = self._parse_string() if self._match_text_seq("LIKE") else None
 568            where = self._parse_where()
 569
 570            if this == "PROFILE":
 571                types = self._parse_csv(lambda: self._parse_var_from_options(self.PROFILE_TYPES))
 572                query = self._parse_number() if self._match_text_seq("FOR", "QUERY") else None
 573                offset = self._parse_number() if self._match_text_seq("OFFSET") else None
 574                limit = self._parse_number() if self._match_text_seq("LIMIT") else None
 575            else:
 576                types, query = None, None
 577                offset, limit = self._parse_oldstyle_limit()
 578
 579            mutex = True if self._match_text_seq("MUTEX") else None
 580            mutex = False if self._match_text_seq("STATUS") else mutex
 581
 582            return self.expression(
 583                exp.Show,
 584                this=this,
 585                target=target_id,
 586                full=full,
 587                log=log,
 588                position=position,
 589                db=db,
 590                channel=channel,
 591                like=like,
 592                where=where,
 593                types=types,
 594                query=query,
 595                offset=offset,
 596                limit=limit,
 597                mutex=mutex,
 598                **{"global": global_},  # type: ignore
 599            )
 600
 601        def _parse_oldstyle_limit(
 602            self,
 603        ) -> t.Tuple[t.Optional[exp.Expression], t.Optional[exp.Expression]]:
 604            limit = None
 605            offset = None
 606            if self._match_text_seq("LIMIT"):
 607                parts = self._parse_csv(self._parse_number)
 608                if len(parts) == 1:
 609                    limit = parts[0]
 610                elif len(parts) == 2:
 611                    limit = parts[1]
 612                    offset = parts[0]
 613
 614            return offset, limit
 615
 616        def _parse_set_item_charset(self, kind: str) -> exp.Expression:
 617            this = self._parse_string() or self._parse_unquoted_field()
 618            return self.expression(exp.SetItem, this=this, kind=kind)
 619
 620        def _parse_set_item_names(self) -> exp.Expression:
 621            charset = self._parse_string() or self._parse_unquoted_field()
 622            if self._match_text_seq("COLLATE"):
 623                collate = self._parse_string() or self._parse_unquoted_field()
 624            else:
 625                collate = None
 626
 627            return self.expression(exp.SetItem, this=charset, collate=collate, kind="NAMES")
 628
 629        def _parse_type(
 630            self, parse_interval: bool = True, fallback_to_identifier: bool = False
 631        ) -> t.Optional[exp.Expression]:
 632            # mysql binary is special and can work anywhere, even in order by operations
 633            # it operates like a no paren func
 634            if self._match(TokenType.BINARY, advance=False):
 635                data_type = self._parse_types(check_func=True, allow_identifiers=False)
 636
 637                if isinstance(data_type, exp.DataType):
 638                    return self.expression(exp.Cast, this=self._parse_column(), to=data_type)
 639
 640            return super()._parse_type(
 641                parse_interval=parse_interval, fallback_to_identifier=fallback_to_identifier
 642            )
 643
 644        def _parse_group_concat(self) -> t.Optional[exp.Expression]:
 645            def concat_exprs(
 646                node: t.Optional[exp.Expression], exprs: t.List[exp.Expression]
 647            ) -> exp.Expression:
 648                if isinstance(node, exp.Distinct) and len(node.expressions) > 1:
 649                    concat_exprs = [
 650                        self.expression(exp.Concat, expressions=node.expressions, safe=True)
 651                    ]
 652                    node.set("expressions", concat_exprs)
 653                    return node
 654                if len(exprs) == 1:
 655                    return exprs[0]
 656                return self.expression(exp.Concat, expressions=args, safe=True)
 657
 658            args = self._parse_csv(self._parse_lambda)
 659
 660            if args:
 661                order = args[-1] if isinstance(args[-1], exp.Order) else None
 662
 663                if order:
 664                    # Order By is the last (or only) expression in the list and has consumed the 'expr' before it,
 665                    # remove 'expr' from exp.Order and add it back to args
 666                    args[-1] = order.this
 667                    order.set("this", concat_exprs(order.this, args))
 668
 669                this = order or concat_exprs(args[0], args)
 670            else:
 671                this = None
 672
 673            separator = self._parse_field() if self._match(TokenType.SEPARATOR) else None
 674
 675            return self.expression(exp.GroupConcat, this=this, separator=separator)
 676
 677        def _parse_json_value(self) -> exp.JSONValue:
 678            this = self._parse_bitwise()
 679            self._match(TokenType.COMMA)
 680            path = self._parse_bitwise()
 681
 682            returning = self._match(TokenType.RETURNING) and self._parse_type()
 683
 684            return self.expression(
 685                exp.JSONValue,
 686                this=this,
 687                path=self.dialect.to_json_path(path),
 688                returning=returning,
 689                on_condition=self._parse_on_condition(),
 690            )
 691
 692    class Generator(generator.Generator):
 693        INTERVAL_ALLOWS_PLURAL_FORM = False
 694        LOCKING_READS_SUPPORTED = True
 695        NULL_ORDERING_SUPPORTED = None
 696        JOIN_HINTS = False
 697        TABLE_HINTS = True
 698        DUPLICATE_KEY_UPDATE_WITH_SET = False
 699        QUERY_HINT_SEP = " "
 700        VALUES_AS_TABLE = False
 701        NVL2_SUPPORTED = False
 702        LAST_DAY_SUPPORTS_DATE_PART = False
 703        JSON_TYPE_REQUIRED_FOR_EXTRACTION = True
 704        JSON_PATH_BRACKETED_KEY_SUPPORTED = False
 705        JSON_KEY_VALUE_PAIR_SEP = ","
 706        SUPPORTS_TO_NUMBER = False
 707        PARSE_JSON_NAME: t.Optional[str] = None
 708        PAD_FILL_PATTERN_IS_REQUIRED = True
 709        WRAP_DERIVED_VALUES = False
 710        VARCHAR_REQUIRES_SIZE = True
 711        SUPPORTS_MEDIAN = False
 712
 713        TRANSFORMS = {
 714            **generator.Generator.TRANSFORMS,
 715            exp.ArrayAgg: rename_func("GROUP_CONCAT"),
 716            exp.CurrentDate: no_paren_current_date_sql,
 717            exp.DateDiff: _remove_ts_or_ds_to_date(
 718                lambda self, e: self.func("DATEDIFF", e.this, e.expression), ("this", "expression")
 719            ),
 720            exp.DateAdd: _remove_ts_or_ds_to_date(date_add_sql("ADD")),
 721            exp.DateStrToDate: datestrtodate_sql,
 722            exp.DateSub: _remove_ts_or_ds_to_date(date_add_sql("SUB")),
 723            exp.DateTrunc: _date_trunc_sql,
 724            exp.Day: _remove_ts_or_ds_to_date(),
 725            exp.DayOfMonth: _remove_ts_or_ds_to_date(rename_func("DAYOFMONTH")),
 726            exp.DayOfWeek: _remove_ts_or_ds_to_date(rename_func("DAYOFWEEK")),
 727            exp.DayOfYear: _remove_ts_or_ds_to_date(rename_func("DAYOFYEAR")),
 728            exp.GroupConcat: lambda self,
 729            e: f"""GROUP_CONCAT({self.sql(e, "this")} SEPARATOR {self.sql(e, "separator") or "','"})""",
 730            exp.ILike: no_ilike_sql,
 731            exp.JSONExtractScalar: arrow_json_extract_sql,
 732            exp.Length: length_or_char_length_sql,
 733            exp.LogicalOr: rename_func("MAX"),
 734            exp.LogicalAnd: rename_func("MIN"),
 735            exp.Max: max_or_greatest,
 736            exp.Min: min_or_least,
 737            exp.Month: _remove_ts_or_ds_to_date(),
 738            exp.NullSafeEQ: lambda self, e: self.binary(e, "<=>"),
 739            exp.NullSafeNEQ: lambda self, e: f"NOT {self.binary(e, '<=>')}",
 740            exp.NumberToStr: rename_func("FORMAT"),
 741            exp.Pivot: no_pivot_sql,
 742            exp.Select: transforms.preprocess(
 743                [
 744                    transforms.eliminate_distinct_on,
 745                    transforms.eliminate_semi_and_anti_joins,
 746                    transforms.eliminate_qualify,
 747                    transforms.eliminate_full_outer_join,
 748                    transforms.unnest_generate_date_array_using_recursive_cte,
 749                ]
 750            ),
 751            exp.StrPosition: lambda self, e: strposition_sql(
 752                self, e, func_name="LOCATE", supports_position=True
 753            ),
 754            exp.StrToDate: _str_to_date_sql,
 755            exp.StrToTime: _str_to_date_sql,
 756            exp.Stuff: rename_func("INSERT"),
 757            exp.TableSample: no_tablesample_sql,
 758            exp.TimeFromParts: rename_func("MAKETIME"),
 759            exp.TimestampAdd: date_add_interval_sql("DATE", "ADD"),
 760            exp.TimestampDiff: lambda self, e: self.func(
 761                "TIMESTAMPDIFF", unit_to_var(e), e.expression, e.this
 762            ),
 763            exp.TimestampSub: date_add_interval_sql("DATE", "SUB"),
 764            exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
 765            exp.TimeStrToTime: lambda self, e: timestrtotime_sql(
 766                self,
 767                e,
 768                include_precision=not e.args.get("zone"),
 769            ),
 770            exp.TimeToStr: _remove_ts_or_ds_to_date(
 771                lambda self, e: self.func("DATE_FORMAT", e.this, self.format_time(e))
 772            ),
 773            exp.Trim: trim_sql,
 774            exp.TryCast: no_trycast_sql,
 775            exp.TsOrDsAdd: date_add_sql("ADD"),
 776            exp.TsOrDsDiff: lambda self, e: self.func("DATEDIFF", e.this, e.expression),
 777            exp.TsOrDsToDate: _ts_or_ds_to_date_sql,
 778            exp.Unicode: lambda self, e: f"ORD(CONVERT({self.sql(e.this)} USING utf32))",
 779            exp.UnixToTime: _unix_to_time_sql,
 780            exp.Week: _remove_ts_or_ds_to_date(),
 781            exp.WeekOfYear: _remove_ts_or_ds_to_date(rename_func("WEEKOFYEAR")),
 782            exp.Year: _remove_ts_or_ds_to_date(),
 783        }
 784
 785        UNSIGNED_TYPE_MAPPING = {
 786            exp.DataType.Type.UBIGINT: "BIGINT",
 787            exp.DataType.Type.UINT: "INT",
 788            exp.DataType.Type.UMEDIUMINT: "MEDIUMINT",
 789            exp.DataType.Type.USMALLINT: "SMALLINT",
 790            exp.DataType.Type.UTINYINT: "TINYINT",
 791            exp.DataType.Type.UDECIMAL: "DECIMAL",
 792        }
 793
 794        TIMESTAMP_TYPE_MAPPING = {
 795            exp.DataType.Type.DATETIME2: "DATETIME",
 796            exp.DataType.Type.SMALLDATETIME: "DATETIME",
 797            exp.DataType.Type.TIMESTAMP: "DATETIME",
 798            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
 799            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
 800        }
 801
 802        TYPE_MAPPING = {
 803            **generator.Generator.TYPE_MAPPING,
 804            **UNSIGNED_TYPE_MAPPING,
 805            **TIMESTAMP_TYPE_MAPPING,
 806        }
 807
 808        TYPE_MAPPING.pop(exp.DataType.Type.MEDIUMTEXT)
 809        TYPE_MAPPING.pop(exp.DataType.Type.LONGTEXT)
 810        TYPE_MAPPING.pop(exp.DataType.Type.TINYTEXT)
 811        TYPE_MAPPING.pop(exp.DataType.Type.MEDIUMBLOB)
 812        TYPE_MAPPING.pop(exp.DataType.Type.LONGBLOB)
 813        TYPE_MAPPING.pop(exp.DataType.Type.TINYBLOB)
 814
 815        PROPERTIES_LOCATION = {
 816            **generator.Generator.PROPERTIES_LOCATION,
 817            exp.TransientProperty: exp.Properties.Location.UNSUPPORTED,
 818            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
 819        }
 820
 821        LIMIT_FETCH = "LIMIT"
 822
 823        LIMIT_ONLY_LITERALS = True
 824
 825        CHAR_CAST_MAPPING = dict.fromkeys(
 826            (
 827                exp.DataType.Type.LONGTEXT,
 828                exp.DataType.Type.LONGBLOB,
 829                exp.DataType.Type.MEDIUMBLOB,
 830                exp.DataType.Type.MEDIUMTEXT,
 831                exp.DataType.Type.TEXT,
 832                exp.DataType.Type.TINYBLOB,
 833                exp.DataType.Type.TINYTEXT,
 834                exp.DataType.Type.VARCHAR,
 835            ),
 836            "CHAR",
 837        )
 838        SIGNED_CAST_MAPPING = dict.fromkeys(
 839            (
 840                exp.DataType.Type.BIGINT,
 841                exp.DataType.Type.BOOLEAN,
 842                exp.DataType.Type.INT,
 843                exp.DataType.Type.SMALLINT,
 844                exp.DataType.Type.TINYINT,
 845                exp.DataType.Type.MEDIUMINT,
 846            ),
 847            "SIGNED",
 848        )
 849
 850        # MySQL doesn't support many datatypes in cast.
 851        # https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html#function_cast
 852        CAST_MAPPING = {
 853            **CHAR_CAST_MAPPING,
 854            **SIGNED_CAST_MAPPING,
 855            exp.DataType.Type.UBIGINT: "UNSIGNED",
 856        }
 857
 858        TIMESTAMP_FUNC_TYPES = {
 859            exp.DataType.Type.TIMESTAMPTZ,
 860            exp.DataType.Type.TIMESTAMPLTZ,
 861        }
 862
 863        # https://dev.mysql.com/doc/refman/8.0/en/keywords.html
 864        RESERVED_KEYWORDS = {
 865            "accessible",
 866            "add",
 867            "all",
 868            "alter",
 869            "analyze",
 870            "and",
 871            "as",
 872            "asc",
 873            "asensitive",
 874            "before",
 875            "between",
 876            "bigint",
 877            "binary",
 878            "blob",
 879            "both",
 880            "by",
 881            "call",
 882            "cascade",
 883            "case",
 884            "change",
 885            "char",
 886            "character",
 887            "check",
 888            "collate",
 889            "column",
 890            "condition",
 891            "constraint",
 892            "continue",
 893            "convert",
 894            "create",
 895            "cross",
 896            "cube",
 897            "cume_dist",
 898            "current_date",
 899            "current_time",
 900            "current_timestamp",
 901            "current_user",
 902            "cursor",
 903            "database",
 904            "databases",
 905            "day_hour",
 906            "day_microsecond",
 907            "day_minute",
 908            "day_second",
 909            "dec",
 910            "decimal",
 911            "declare",
 912            "default",
 913            "delayed",
 914            "delete",
 915            "dense_rank",
 916            "desc",
 917            "describe",
 918            "deterministic",
 919            "distinct",
 920            "distinctrow",
 921            "div",
 922            "double",
 923            "drop",
 924            "dual",
 925            "each",
 926            "else",
 927            "elseif",
 928            "empty",
 929            "enclosed",
 930            "escaped",
 931            "except",
 932            "exists",
 933            "exit",
 934            "explain",
 935            "false",
 936            "fetch",
 937            "first_value",
 938            "float",
 939            "float4",
 940            "float8",
 941            "for",
 942            "force",
 943            "foreign",
 944            "from",
 945            "fulltext",
 946            "function",
 947            "generated",
 948            "get",
 949            "grant",
 950            "group",
 951            "grouping",
 952            "groups",
 953            "having",
 954            "high_priority",
 955            "hour_microsecond",
 956            "hour_minute",
 957            "hour_second",
 958            "if",
 959            "ignore",
 960            "in",
 961            "index",
 962            "infile",
 963            "inner",
 964            "inout",
 965            "insensitive",
 966            "insert",
 967            "int",
 968            "int1",
 969            "int2",
 970            "int3",
 971            "int4",
 972            "int8",
 973            "integer",
 974            "intersect",
 975            "interval",
 976            "into",
 977            "io_after_gtids",
 978            "io_before_gtids",
 979            "is",
 980            "iterate",
 981            "join",
 982            "json_table",
 983            "key",
 984            "keys",
 985            "kill",
 986            "lag",
 987            "last_value",
 988            "lateral",
 989            "lead",
 990            "leading",
 991            "leave",
 992            "left",
 993            "like",
 994            "limit",
 995            "linear",
 996            "lines",
 997            "load",
 998            "localtime",
 999            "localtimestamp",
1000            "lock",
1001            "long",
1002            "longblob",
1003            "longtext",
1004            "loop",
1005            "low_priority",
1006            "master_bind",
1007            "master_ssl_verify_server_cert",
1008            "match",
1009            "maxvalue",
1010            "mediumblob",
1011            "mediumint",
1012            "mediumtext",
1013            "middleint",
1014            "minute_microsecond",
1015            "minute_second",
1016            "mod",
1017            "modifies",
1018            "natural",
1019            "not",
1020            "no_write_to_binlog",
1021            "nth_value",
1022            "ntile",
1023            "null",
1024            "numeric",
1025            "of",
1026            "on",
1027            "optimize",
1028            "optimizer_costs",
1029            "option",
1030            "optionally",
1031            "or",
1032            "order",
1033            "out",
1034            "outer",
1035            "outfile",
1036            "over",
1037            "partition",
1038            "percent_rank",
1039            "precision",
1040            "primary",
1041            "procedure",
1042            "purge",
1043            "range",
1044            "rank",
1045            "read",
1046            "reads",
1047            "read_write",
1048            "real",
1049            "recursive",
1050            "references",
1051            "regexp",
1052            "release",
1053            "rename",
1054            "repeat",
1055            "replace",
1056            "require",
1057            "resignal",
1058            "restrict",
1059            "return",
1060            "revoke",
1061            "right",
1062            "rlike",
1063            "row",
1064            "rows",
1065            "row_number",
1066            "schema",
1067            "schemas",
1068            "second_microsecond",
1069            "select",
1070            "sensitive",
1071            "separator",
1072            "set",
1073            "show",
1074            "signal",
1075            "smallint",
1076            "spatial",
1077            "specific",
1078            "sql",
1079            "sqlexception",
1080            "sqlstate",
1081            "sqlwarning",
1082            "sql_big_result",
1083            "sql_calc_found_rows",
1084            "sql_small_result",
1085            "ssl",
1086            "starting",
1087            "stored",
1088            "straight_join",
1089            "system",
1090            "table",
1091            "terminated",
1092            "then",
1093            "tinyblob",
1094            "tinyint",
1095            "tinytext",
1096            "to",
1097            "trailing",
1098            "trigger",
1099            "true",
1100            "undo",
1101            "union",
1102            "unique",
1103            "unlock",
1104            "unsigned",
1105            "update",
1106            "usage",
1107            "use",
1108            "using",
1109            "utc_date",
1110            "utc_time",
1111            "utc_timestamp",
1112            "values",
1113            "varbinary",
1114            "varchar",
1115            "varcharacter",
1116            "varying",
1117            "virtual",
1118            "when",
1119            "where",
1120            "while",
1121            "window",
1122            "with",
1123            "write",
1124            "xor",
1125            "year_month",
1126            "zerofill",
1127        }
1128
1129        def array_sql(self, expression: exp.Array) -> str:
1130            self.unsupported("Arrays are not supported by MySQL")
1131            return self.function_fallback_sql(expression)
1132
1133        def arraycontainsall_sql(self, expression: exp.ArrayContainsAll) -> str:
1134            self.unsupported("Array operations are not supported by MySQL")
1135            return self.function_fallback_sql(expression)
1136
1137        def dpipe_sql(self, expression: exp.DPipe) -> str:
1138            return self.func("CONCAT", *expression.flatten())
1139
1140        def extract_sql(self, expression: exp.Extract) -> str:
1141            unit = expression.name
1142            if unit and unit.lower() == "epoch":
1143                return self.func("UNIX_TIMESTAMP", expression.expression)
1144
1145            return super().extract_sql(expression)
1146
1147        def datatype_sql(self, expression: exp.DataType) -> str:
1148            if (
1149                self.VARCHAR_REQUIRES_SIZE
1150                and expression.is_type(exp.DataType.Type.VARCHAR)
1151                and not expression.expressions
1152            ):
1153                # `VARCHAR` must always have a size - if it doesn't, we always generate `TEXT`
1154                return "TEXT"
1155
1156            # https://dev.mysql.com/doc/refman/8.0/en/numeric-type-syntax.html
1157            result = super().datatype_sql(expression)
1158            if expression.this in self.UNSIGNED_TYPE_MAPPING:
1159                result = f"{result} UNSIGNED"
1160
1161            return result
1162
1163        def jsonarraycontains_sql(self, expression: exp.JSONArrayContains) -> str:
1164            return f"{self.sql(expression, 'this')} MEMBER OF({self.sql(expression, 'expression')})"
1165
1166        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
1167            if expression.to.this in self.TIMESTAMP_FUNC_TYPES:
1168                return self.func("TIMESTAMP", expression.this)
1169
1170            to = self.CAST_MAPPING.get(expression.to.this)
1171
1172            if to:
1173                expression.to.set("this", to)
1174            return super().cast_sql(expression)
1175
1176        def show_sql(self, expression: exp.Show) -> str:
1177            this = f" {expression.name}"
1178            full = " FULL" if expression.args.get("full") else ""
1179            global_ = " GLOBAL" if expression.args.get("global") else ""
1180
1181            target = self.sql(expression, "target")
1182            target = f" {target}" if target else ""
1183            if expression.name in ("COLUMNS", "INDEX"):
1184                target = f" FROM{target}"
1185            elif expression.name == "GRANTS":
1186                target = f" FOR{target}"
1187
1188            db = self._prefixed_sql("FROM", expression, "db")
1189
1190            like = self._prefixed_sql("LIKE", expression, "like")
1191            where = self.sql(expression, "where")
1192
1193            types = self.expressions(expression, key="types")
1194            types = f" {types}" if types else types
1195            query = self._prefixed_sql("FOR QUERY", expression, "query")
1196
1197            if expression.name == "PROFILE":
1198                offset = self._prefixed_sql("OFFSET", expression, "offset")
1199                limit = self._prefixed_sql("LIMIT", expression, "limit")
1200            else:
1201                offset = ""
1202                limit = self._oldstyle_limit_sql(expression)
1203
1204            log = self._prefixed_sql("IN", expression, "log")
1205            position = self._prefixed_sql("FROM", expression, "position")
1206
1207            channel = self._prefixed_sql("FOR CHANNEL", expression, "channel")
1208
1209            if expression.name == "ENGINE":
1210                mutex_or_status = " MUTEX" if expression.args.get("mutex") else " STATUS"
1211            else:
1212                mutex_or_status = ""
1213
1214            return f"SHOW{full}{global_}{this}{target}{types}{db}{query}{log}{position}{channel}{mutex_or_status}{like}{where}{offset}{limit}"
1215
1216        def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
1217            dtype = self.sql(expression, "dtype")
1218            if not dtype:
1219                return super().altercolumn_sql(expression)
1220
1221            this = self.sql(expression, "this")
1222            return f"MODIFY COLUMN {this} {dtype}"
1223
1224        def _prefixed_sql(self, prefix: str, expression: exp.Expression, arg: str) -> str:
1225            sql = self.sql(expression, arg)
1226            return f" {prefix} {sql}" if sql else ""
1227
1228        def _oldstyle_limit_sql(self, expression: exp.Show) -> str:
1229            limit = self.sql(expression, "limit")
1230            offset = self.sql(expression, "offset")
1231            if limit:
1232                limit_offset = f"{offset}, {limit}" if offset else limit
1233                return f" LIMIT {limit_offset}"
1234            return ""
1235
1236        def chr_sql(self, expression: exp.Chr) -> str:
1237            this = self.expressions(sqls=[expression.this] + expression.expressions)
1238            charset = expression.args.get("charset")
1239            using = f" USING {self.sql(charset)}" if charset else ""
1240            return f"CHAR({this}{using})"
1241
1242        def timestamptrunc_sql(self, expression: exp.TimestampTrunc) -> str:
1243            unit = expression.args.get("unit")
1244
1245            # Pick an old-enough date to avoid negative timestamp diffs
1246            start_ts = "'0000-01-01 00:00:00'"
1247
1248            # Source: https://stackoverflow.com/a/32955740
1249            timestamp_diff = build_date_delta(exp.TimestampDiff)([unit, start_ts, expression.this])
1250            interval = exp.Interval(this=timestamp_diff, unit=unit)
1251            dateadd = build_date_delta_with_interval(exp.DateAdd)([start_ts, interval])
1252
1253            return self.sql(dateadd)
1254
1255        def converttimezone_sql(self, expression: exp.ConvertTimezone) -> str:
1256            from_tz = expression.args.get("source_tz")
1257            to_tz = expression.args.get("target_tz")
1258            dt = expression.args.get("timestamp")
1259
1260            return self.func("CONVERT_TZ", dt, from_tz, to_tz)
1261
1262        def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
1263            self.unsupported("AT TIME ZONE is not supported by MySQL")
1264            return self.sql(expression.this)
1265
1266        def isascii_sql(self, expression: exp.IsAscii) -> str:
1267            return f"REGEXP_LIKE({self.sql(expression.this)}, '^[[:ascii:]]*$')"