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